def shift_contract_by_maturity(self,c_1:BaseFuture,account:BaseAccount):
if not c_1.has_next():
trade_unit = account.trade_book.loc[c_1.id_instrument(), Util.TRADE_UNIT]
direction = account.trade_book.loc[c_1.id_instrument(), Util.TRADE_LONG_SHORT]
if direction == c.LongShort.LONG:
close_direction = c.LongShort.SHORT
else:
close_direction = c.LongShort.LONG
order = account.create_trade_order(c_1, close_direction, trade_unit)
record = c_1.execute_order(order)
account.add_record(record, c_1)
# open same position by current most active contract
c_1_new = self.select_c_1()
order = account.create_trade_order(c_1_new, direction, trade_unit)
record = c_1_new.execute_order(order)
account.add_record(record, c_1_new)
return True
else:
return False
class ParityArbitrage(object):
def __init__(self,name_code, df_option, df_etf=None, df_future_all=None,df_index=None):
self.name_code = name_code
self.df_option = df_option
self.df_etf = df_etf
self.df_future_all = df_future_all
self.df_index = df_index
self.rf = 0.03
self.m = 0.9
self.account = BaseAccount(c.Util.BILLION / 10,rf=self.rf)
self.unit = 50
self.min_holding = 6 # 50ETF与IH到期日相差5天
self.nbr_maturity = 0
self.rank = 3
self.slippage = 0
self.aggregate_costs = 0.5/100.0
self.cd_price = c.CdTradePrice.CLOSE
self.df_arbitrage_window = pd.DataFrame()
def init(self):
self.underlying = None
self.futureset = None
self.baseindex = None
self.optionset = BaseOptionSet(self.df_option)
self.optionset.init()
if self.name_code == c.Util.STR_50ETF:
if self.df_etf is not None:
self.underlying = BaseInstrument(self.df_etf) # 50ETF
self.underlying.init()
if self.df_future_all is not None:
self.futureset = BaseFutureSet(self.df_future_all) # IH
self.futureset.init()
self.future_unit_ratio = 1/1000.0
if self.df_index is not None:
self.baseindex = BaseInstrument(self.df_index) # SH50
self.baseindex.init()
else: # 商品期权
if self.df_future_all is not None:
self.futureset = BaseFutureSet(self.df_future_all) # IH
self.futureset.init()
self.future_unit_ratio = 1.0
# self.optionset = BaseOptionSet(self.df_option)
# self.optionset.init()
def update_sythetics(self):
if self.name_code == c.Util.STR_50ETF:
dt_maturity = self.optionset.select_maturity_date(nbr_maturity=self.nbr_maturity, min_holding=self.min_holding)
contract_month = self.optionset.get_dict_options_by_maturities()[dt_maturity][0].contract_month()
self.t_quote = self.optionset.get_T_quotes(dt_maturity, self.cd_price)
self.t_quote.loc[:, 'diff'] = abs(
self.t_quote.loc[:, c.Util.AMT_APPLICABLE_STRIKE] - self.t_quote.loc[:, c.Util.AMT_UNDERLYING_CLOSE])
self.t_quote.loc[:, 'rank'] = self.t_quote.index - self.t_quote['diff'].idxmin()
discount = c.PricingUtil.get_discount(self.optionset.eval_date, dt_maturity, self.rf)
self.t_quote.loc[:, 'sythetic_underlying'] = self.t_quote.loc[:, c.Util.AMT_CALL_QUOTE] \
- self.t_quote.loc[:,c.Util.AMT_PUT_QUOTE] \
+ self.t_quote.loc[:,c.Util.AMT_APPLICABLE_STRIKE] * discount
df_window = self.t_quote[(self.t_quote['rank']<=self.rank)&(self.t_quote['rank']>=-self.rank)] # 只考虑rank以内期权
self.row_max_sythetic = df_window.loc[df_window['sythetic_underlying'].idxmax()]
self.row_min_sythetic = df_window.loc[df_window['sythetic_underlying'].idxmin()]
self.df_arbitrage_window.loc[self.optionset.eval_date,'50etf'] = self.underlying.mktprice_close()
self.df_arbitrage_window.loc[self.optionset.eval_date,'sythetic_underlying_max'] = self.row_max_sythetic['sythetic_underlying']
self.df_arbitrage_window.loc[self.optionset.eval_date,'sythetic_underlying_min'] = self.row_min_sythetic['sythetic_underlying']
if self.futureset is not None:
future = self.futureset.select_future_by_contract_month(contract_month)
self.row_max_sythetic['future'] = future
if future is None:
return
self.basis_to_etf = future.mktprice_close() - self.underlying.mktprice_close()/self.future_unit_ratio
self.df_arbitrage_window.loc[self.optionset.eval_date, 'basis_to_etf'] = self.basis_to_etf
self.df_arbitrage_window.loc[self.optionset.eval_date, 'ih'] = future.mktprice_close()
if self.baseindex is not None:
self.basis_to_index = future.mktprice_close() - self.baseindex.mktprice_close()
self.tracking_error = self.underlying.mktprice_close()/self.future_unit_ratio - self.baseindex.mktprice_close()
self.df_arbitrage_window.loc[self.optionset.eval_date, 'basis_to_index'] = self.basis_to_index
self.df_arbitrage_window.loc[self.optionset.eval_date, 'tracking_error'] = self.tracking_error
self.df_arbitrage_window.loc[self.optionset.eval_date, 'index_50'] = self.baseindex.mktprice_close()
else:
dt_maturity = self.optionset.select_maturity_date(nbr_maturity=self.nbr_maturity, min_holding=self.min_holding)
contract_month = self.optionset.get_dict_options_by_maturities()[dt_maturity][0].contract_month()
self.t_quote = self.optionset.get_T_quotes(dt_maturity, self.cd_price)
self.t_quote.loc[:, 'diff'] = abs(
self.t_quote.loc[:, c.Util.AMT_APPLICABLE_STRIKE] - self.t_quote.loc[:, c.Util.AMT_UNDERLYING_CLOSE])
self.t_quote.loc[:, 'rank'] = self.t_quote.index - self.t_quote['diff'].idxmin()
discount = c.PricingUtil.get_discount(self.optionset.eval_date, dt_maturity, self.rf)
self.t_quote.loc[:, 'sythetic_underlying'] = self.t_quote.loc[:, c.Util.AMT_CALL_QUOTE] \
- self.t_quote.loc[:,c.Util.AMT_PUT_QUOTE] \
+ self.t_quote.loc[:,c.Util.AMT_APPLICABLE_STRIKE] * discount
df_window = self.t_quote[(self.t_quote['rank']<=self.rank)&(self.t_quote['rank']>=-self.rank)] # 只考虑rank以内期权
self.row_max_sythetic = df_window.loc[df_window['sythetic_underlying'].idxmax()]
self.row_min_sythetic = df_window.loc[df_window['sythetic_underlying'].idxmin()]
future = self.futureset.select_future_by_contract_month(contract_month)
self.underlying = future
self.df_arbitrage_window.loc[self.optionset.eval_date, 'underlying'] = self.underlying.mktprice_close()
self.df_arbitrage_window.loc[self.optionset.eval_date, 'sythetic_underlying_max'] = self.row_max_sythetic[
'sythetic_underlying']
self.df_arbitrage_window.loc[self.optionset.eval_date, 'sythetic_underlying_min'] = self.row_min_sythetic[
'sythetic_underlying']
def open_signal(self,cd_strategy):
if cd_strategy == 'box':
if (self.row_max_sythetic['sythetic_underlying'] - self.row_min_sythetic['sythetic_underlying'])/self.underlying.mktprice_close() > self.aggregate_costs:
df = pd.DataFrame(columns=['dt_date','id_instrument','base_instrument','long_short'])
df = self.short_sythetic(df)
df = self.long_sythetic(df)
return df
else:
return None
elif cd_strategy == 'conversion': # Converion : Short Sythetic, Long ETF
if (self.row_max_sythetic['sythetic_underlying'] - self.underlying.mktprice_close())/self.underlying.mktprice_close() > self.aggregate_costs:
df = pd.DataFrame(columns=['dt_date','id_instrument','base_instrument','long_short'])
df = self.short_sythetic(df)
df = self.long_etf(df)
return df
else:
return None
elif cd_strategy == 'conversion_ih': # Converion : Short Sythetic, Long IH # 主要布局IH负基差套利
if self.optionset.eval_date.month ==5: return None #5月由于股票集中现金分红不做空Synthetic
future = self.row_max_sythetic['future']
if future is None: return None
self.future = future
if (self.row_max_sythetic['sythetic_underlying']/self.future_unit_ratio - future.mktprice_close()-
self.df_arbitrage_window.loc[self.optionset.eval_date,'tracking_error'])/future.mktprice_close() > self.aggregate_costs:
df = pd.DataFrame(columns=['dt_date', 'id_instrument', 'base_instrument', 'long_short'])
df = self.short_sythetic(df)
df = self.long_ih(df,future)
return df
else:
return None
elif cd_strategy == 'ih_basis_arbitrage':
future = self.row_max_sythetic['future']
if future is None: return None
self.future = future
if self.df_arbitrage_window.loc[self.optionset.eval_date, 'basis_to_index'] < -self.aggregate_costs: # 期货贴水
df = pd.DataFrame(columns=['dt_date', 'id_instrument', 'base_instrument', 'long_short'])
df = self.short_sythetic(df)
df = self.long_ih(df,future)
return df
else:
return None
elif cd_strategy == 'may_effect': # Reverse: Long Sythetic, Short IH # 5-9月分红期
if self.optionset.eval_date.month ==5: #5月由于股票集中现金分红不做空Synthetic
df = pd.DataFrame(columns=['dt_date', 'id_instrument', 'base_instrument', 'long_short'])
df = self.long_sythetic(df)
df = self.short_ih(df)
return df
else:
return None
def close_signal(self,cd_strategy,df_position):
if cd_strategy == 'box':
if self.reverse_call.maturitydt() == self.optionset.eval_date or self.conversion_call.maturitydt() == self.optionset.eval_date :
return True
discount_r = c.PricingUtil.get_discount(self.optionset.eval_date, self.reverse_put.maturitydt(), self.rf)
discount_c = c.PricingUtil.get_discount(self.optionset.eval_date, self.conversion_put.maturitydt(), self.rf)
reverse_sythetic = self.reverse_call.mktprice_close()-self.reverse_put.mktprice_close()+self.reverse_put.applicable_strike()*discount_r # Longed
conversion_sythetic = self.conversion_call.mktprice_close()-self.conversion_put.mktprice_close()+self.conversion_put.applicable_strike()*discount_c # shorted
if conversion_sythetic <= reverse_sythetic:
return True
else:
return False
elif cd_strategy == 'conversion': # Short Sythetic, Long Underlying # 主要布局IH负基差套利
if self.conversion_call.maturitydt() == self.optionset.eval_date:
return True
discount_c = c.PricingUtil.get_discount(self.optionset.eval_date, self.conversion_put.maturitydt(), self.rf)
conversion_sythetic = self.conversion_call.mktprice_close() - self.conversion_put.mktprice_close() + self.conversion_put.applicable_strike() * discount_c # shorted
if conversion_sythetic/self.future_unit_ratio <= self.underlying.mktprice_close():
return True
else:
return False
elif cd_strategy == 'conversion_ih': # Short Sythetic, Long IH # 主要布局IH负基差套利
if self.conversion_call.maturitydt() == self.optionset.eval_date or self.future.maturitydt() == self.optionset.eval_date:
return True
discount_c = c.PricingUtil.get_discount(self.optionset.eval_date, self.conversion_put.maturitydt(), self.rf)
conversion_sythetic = self.conversion_call.mktprice_close() - self.conversion_put.mktprice_close() + self.conversion_put.applicable_strike() * discount_c # shorted
if conversion_sythetic/self.future_unit_ratio <= self.future.mktprice_close():
return True
else:
return False
elif cd_strategy == 'ih_basis_arbitrage':
if self.df_arbitrage_window.loc[self.optionset.eval_date, 'basis_to_index'] >= 0:
return True
else:
return False
elif cd_strategy == 'may_effect': # Reverse: Long Sythetic, Short IH # 5-9月分红期
if self.optionset.eval_date.month !=5: #5月由于股票集中现金分红不做空Synthetic
return True
else:
return False
def open_excute(self,open_signal):
if open_signal is None:
return False
else:
fund_per_unit = open_signal['fund_requirement'].sum()
unit = np.floor(self.account.cash*self.m/fund_per_unit)
for (idx,row) in open_signal.iterrows():
option = row['base_instrument']
order = self.account.create_trade_order(option, row['long_short'], unit*row['unit_ratio'],
cd_trade_price=self.cd_price)
record = option.execute_order(order, slippage=self.slippage)
self.account.add_record(record, option)
print(self.optionset.eval_date, ' open position')
return True
def close_excute(self):
self.close_out()
print(self.optionset.eval_date, ' close position')
return True
# else:
# for (idx,row) in close_signal.iterrows():
# option = row['base_instrument']
# order = self.account.create_trade_order(option, row['long_short'], row['unit'],
# cd_trade_price=self.cd_price)
# record = option.execute_order(order, slippage=self.slippage)
# self.account.add_record(record, option)
# return True
def close_out(self):
close_out_orders = self.account.creat_close_out_order(cd_trade_price=c.CdTradePrice.CLOSE)
for order in close_out_orders:
execution_record = self.account.dict_holding[order.id_instrument] \
.execute_order(order, slippage=self.slippage, execute_type=c.ExecuteType.EXECUTE_ALL_UNITS)
self.account.add_record(execution_record, self.account.dict_holding[order.id_instrument])
def short_sythetic(self,df):
# Short Sythetic
self.conversion_call = self.optionset.get_baseoption_by_id(self.row_max_sythetic[c.Util.ID_CALL])
fund_requirement = self.conversion_call.get_fund_required(c.LongShort.SHORT)
df = df.append({'dt_date': self.optionset.eval_date,
'cd_posiiton': 'C_call',
'id_instrument': self.row_max_sythetic[c.Util.ID_CALL],
'base_instrument': self.conversion_call,
'long_short': c.LongShort.SHORT,
'fund_requirement': fund_requirement,
'cashflow_t0': self.conversion_call.mktprice_close() * self.conversion_call.multiplier(),
'unit_ratio' : 1},
ignore_index=True)
self.conversion_put = self.optionset.get_baseoption_by_id(self.row_max_sythetic[c.Util.ID_PUT])
fund_requirement = self.conversion_put.get_fund_required(c.LongShort.LONG)
df = df.append({'dt_date': self.optionset.eval_date,
'cd_posiiton': 'C_put',
'id_instrument': self.row_max_sythetic[c.Util.ID_PUT],
'base_instrument': self.conversion_put,
'long_short': c.LongShort.LONG,
'fund_requirement': fund_requirement,
'cashflow_t0': -self.conversion_put.mktprice_close() * self.conversion_put.multiplier(),
'unit_ratio' : 1},
ignore_index=True)
return df
def long_sythetic(self,df):
# Reverse : Long Sythetic
self.reverse_call = self.optionset.get_baseoption_by_id(self.row_min_sythetic[c.Util.ID_CALL])
fund_requirement = self.reverse_call.get_fund_required(c.LongShort.LONG)
df = df.append({'dt_date': self.optionset.eval_date,
'cd_posiiton': 'R_call',
'id_instrument': self.row_min_sythetic[c.Util.ID_CALL],
'base_instrument': self.reverse_call,
'long_short': c.LongShort.LONG,
'fund_requirement': fund_requirement,
'cashflow_t0': -self.reverse_call.mktprice_close() * self.reverse_call.multiplier()},
ignore_index=True)
self.reverse_put = self.optionset.get_baseoption_by_id(self.row_min_sythetic[c.Util.ID_PUT])
fund_requirement = self.reverse_put.get_fund_required(c.LongShort.SHORT)
df = df.append({'dt_date': self.optionset.eval_date,
'cd_posiiton': 'R_put',
'id_instrument': self.row_min_sythetic[c.Util.ID_PUT],
'base_instrument': self.reverse_put,
'long_short': c.LongShort.SHORT,
'fund_requirement': fund_requirement,
'cashflow_t0': self.reverse_put.mktprice_close() * self.reverse_put.multiplier()},
ignore_index=True)
return df
def long_etf(self,df):
unit_ratio = self.conversion_put.multiplier()
fund_requirement = self.conversion_put.multiplier() * self.underlying.mktprice_close()
df = df.append({'dt_date': self.optionset.eval_date,
'cd_posiiton': 'underlying',
'id_instrument': self.underlying.id_instrument(),
'base_instrument': self.underlying,
'long_short': c.LongShort.LONG,
'fund_requirement': fund_requirement,
'cashflow_t0': -self.underlying.mktprice_close() * self.underlying.multiplier()*unit_ratio,
'unit_ratio' : unit_ratio},
ignore_index=True)
return df
def long_ih(self,df,future):
unit_ratio = self.conversion_put.multiplier()/future.multiplier()/1000.0
fund_requirement = future.mktprice_close()*future.multiplier()*unit_ratio
df = df.append({'dt_date': self.optionset.eval_date,
'cd_posiiton': 'underlying',
'id_instrument': future.id_instrument(),
'base_instrument': future,
'long_short': c.LongShort.LONG,
'fund_requirement': fund_requirement,
'cashflow_t0': -future.mktprice_close() * future.multiplier()*unit_ratio,
'unit_ratio' : unit_ratio},
ignore_index=True)
return df
def short_ih(self,df):
unit_ratio = self.reverse_put.multiplier()/self.future.multiplier()/1000.0
fund_requirement = self.future.mktprice_close()*self.future.multiplier()*unit_ratio
df = df.append({'dt_date': self.optionset.eval_date,
'cd_posiiton': 'underlying',
'id_instrument': self.future.id_instrument(),
'base_instrument': self.future,
'long_short': c.LongShort.SHORT,
'fund_requirement': fund_requirement,
'cashflow_t0': -self.future.mktprice_close() * self.future.multiplier()*unit_ratio,
'unit_ratio' : unit_ratio},
ignore_index=True)
return df
def back_test(self, cd_strategy):
# TODO: DIVIDEND
empty_position = True
df_position = None
while self.optionset.has_next():
# if self.optionset.eval_date == datetime.date(2015,5,18):
# print('')
self.update_sythetics()
if empty_position:
df_position = self.open_signal(cd_strategy)
empty_position = not self.open_excute(df_position)
elif self.close_signal(cd_strategy,df_position):
empty_position = self.close_excute()
# if isinstance(self.underlying,BaseFutureCoutinuous):
# self.underlying.shift_contract_month(self.account,self.slippage)
self.account.daily_accounting(self.optionset.eval_date)
self.optionset.next()
self.underlying.next()
if self.futureset is not None: self.futureset.next()
if self.baseindex is not None: self.baseindex.next()
# print(self.optionset.eval_date)
return self.account
def back_test_comdty(self, cd_strategy):
empty_position = True
df_position = None
while self.optionset.has_next():
# if self.optionset.eval_date == datetime.date(2015,5,18):
# print('')
self.update_sythetics()
if empty_position:
df_position = self.open_signal(cd_strategy)
empty_position = not self.open_excute(df_position)
elif self.close_signal(cd_strategy,df_position):
empty_position = self.close_excute()
# if isinstance(self.underlying,BaseFutureCoutinuous):
# self.underlying.shift_contract_month(self.account,self.slippage)
self.account.daily_accounting(self.optionset.eval_date)
self.optionset.next()
self.futureset.next()
# if self.baseindex is not None: self.baseindex.next()
# print(self.optionset.eval_date)
return self.account
unit_p = None
unit_c = None
atm_strike = None
buy_write = c.BuyWrite.WRITE
print(optionset.eval_date, hedging.eval_date)
while optionset.eval_date <= end_date:
if account.cash <= 0: break
if maturity1 > end_date: # Final close out all.
close_out_orders = account.creat_close_out_order()
for order in close_out_orders:
execution_record = account.dict_holding[
order.id_instrument].execute_order(
order,
slippage=0,
execute_type=c.ExecuteType.EXECUTE_ALL_UNITS)
account.add_record(execution_record,
account.dict_holding[order.id_instrument])
account.daily_accounting(optionset.eval_date)
print(optionset.eval_date, ' close out ')
print(optionset.eval_date, hedging.eval_date,
account.account.loc[optionset.eval_date, c.Util.PORTFOLIO_NPV],
int(account.cash))
break
if not empty_position:
moneyness_put = optionset.get_option_moneyness(atm_put)
moneyness_call = optionset.get_option_moneyness(atm_call)
if close_signal(optionset.eval_date, maturity1, df_iv_stats):
for option in account.dict_holding.values():
order = account.create_close_order(option)
record = option.execute_order(order, slippage=slippage)
account.add_record(record, option)
option_amt = []
optionset = BaseOptionSet(df_metrics)
optionset.init()
underlying = BaseInstrument(df_underlying)
underlying.init()
account = BaseAccount(init_fund=10000000, leverage=1.0, rf=0.03)
""" init open position """
unit_underlying = np.floor(pct_underlying_invest * account.cash /
underlying.mktprice_close() /
underlying.multiplier())
order_underlying = account.create_trade_order(underlying,
c.LongShort.LONG,
unit_underlying)
record_underlying = underlying.execute_order(order_underlying,
slippage=slippage)
account.add_record(record_underlying, underlying)
maturity1 = optionset.select_maturity_date(nbr_maturity=nbr_maturity,
min_holding=min_holding)
list_atm_call, list_atm_put = optionset.get_options_list_by_moneyness_mthd1(
moneyness, maturity1)
if list_atm_put is None:
# list_atm_call, list_atm_put = optionset.get_options_list_by_moneyness_mthd1(0, maturity1)
print('choose min strike')
list_atm_put = optionset.get_deepest_otm_put_list(maturity1)
atm_put = optionset.select_higher_volume(list_atm_put)
underlying_value = unit_underlying * underlying.mktprice_close(
) * underlying.multiplier()
unit = get_option_unit(atm_put, underlying_value, target_delta)
order = account.create_trade_order(atm_put, c.LongShort.LONG, unit)
record = atm_put.execute_order(order, slippage=slippage)
account.add_record(record, atm_put)
Option = EuropeanOption(strike, dt_maturity, OptionType.PUT)
delta = synthetic_option.get_black_delta(Option, vol)
id_future = synthetic_option.current_state[Util.ID_INSTRUMENT]
synthetic_unit = synthetic_option.get_synthetic_unit(delta)
if synthetic_unit > 0:
long_short = LongShort.LONG
else:
long_short = LongShort.SHORT
# """ 用第一天的日收盘价开仓标的现货多头头寸 """
underlying_unit = np.floor(Util.BILLION / underlying.mktprice_close())
order_underlying = account.create_trade_order(underlying, LongShort.LONG,
underlying_unit)
execution_record = underlying.execute_order(
order_underlying, slippage=0, execute_type=ExecuteType.EXECUTE_ALL_UNITS)
account.add_record(execution_record, underlying)
underlying.next()
# """ 用第一天的成交量加权均价初次开仓复制期权头寸 """
order = account.create_trade_order(synthetic_option, long_short,
synthetic_unit)
execution_record = synthetic_option.execute_order_by_VWAP(
order, slippage=0, execute_type=ExecuteType.EXECUTE_ALL_UNITS)
account.add_record(execution_record, synthetic_option)
#####################################################################
while synthetic_option.has_next() and synthetic_option.eval_date < dt_maturity:
if id_future != synthetic_option.current_state[Util.ID_INSTRUMENT]:
open_long_short = account.trade_book.loc[id_future,
Util.TRADE_LONG_SHORT]
hold_unit = account.trade_book.loc[id_future, Util.TRADE_UNIT]
spot = synthetic_option.current_daily_state[Util.AMT_CLOSE]
class HoldFutureContinuous(object):
def __init__(self, df_c1, df_all, df_baseindex):
self.slippage = 0
self.cd_trade_price = c.CdTradePrice.VOLUME_WEIGHTED
dt_start = max(df_baseindex[c.Util.DT_DATE].values[0],
df_c1[c.Util.DT_DATE].values[0])
self.end_date = min(df_baseindex[c.Util.DT_DATE].values[-1],
df_c1[c.Util.DT_DATE].values[-1])
df_baseindex = df_baseindex[
df_baseindex[c.Util.DT_DATE] >= dt_start].reset_index(drop=True)
df_c1 = df_c1[df_c1[c.Util.DT_DATE] >= dt_start].reset_index(drop=True)
df_all = df_all[df_all[c.Util.DT_DATE] >= dt_start].reset_index(
drop=True)
self.invst_portfolio = BaseFutureCoutinuous(
df_c1,
df_futures_all_daily=df_all) # e.g., top 50 low volatility index
self.invst_portfolio.init()
self.index = BaseInstrument(df_baseindex)
self.index.init()
self.account = BaseAccount(init_fund=c.Util.BILLION,
leverage=1.0,
rf=0.03)
def close_all_options(self):
for option in self.account.dict_holding.values():
if isinstance(option, BaseOption):
order = self.account.create_close_order(
option, cd_trade_price=self.cd_trade_price)
record = option.execute_order(order, slippage=self.slippage)
self.account.add_record(record, option)
self.dict_strategy = {}
def close_out(self):
close_out_orders = self.account.creat_close_out_order(
cd_trade_price=c.CdTradePrice.CLOSE)
for order in close_out_orders:
execution_record = self.account.dict_holding[order.id_instrument] \
.execute_order(order, slippage=self.slippage, execute_type=c.ExecuteType.EXECUTE_ALL_UNITS)
self.account.add_record(
execution_record,
self.account.dict_holding[order.id_instrument])
def back_test(self):
self.unit_index = np.floor(self.account.cash /
self.index.mktprice_close() /
self.index.multiplier())
unit_portfolio = np.floor(self.account.cash /
self.invst_portfolio.mktprice_close() /
self.invst_portfolio.multiplier())
order_index = self.account.create_trade_order(
self.invst_portfolio,
c.LongShort.LONG,
unit_portfolio,
cd_trade_price=c.CdTradePrice.CLOSE)
record_index = self.invst_portfolio.execute_order(
order_index, slippage=self.slippage)
self.account.add_record(record_index, self.invst_portfolio)
init_index = self.index.mktprice_close()
index_npv = []
while self.invst_portfolio.eval_date <= self.end_date:
if self.invst_portfolio.eval_date >= self.end_date: # Final close out all.
close_out_orders = self.account.creat_close_out_order()
for order in close_out_orders:
execution_record = self.account.dict_holding[order.id_instrument] \
.execute_order(order, slippage=self.slippage, execute_type=c.ExecuteType.EXECUTE_ALL_UNITS)
self.account.add_record(
execution_record,
self.account.dict_holding[order.id_instrument])
self.account.daily_accounting(self.invst_portfolio.eval_date)
index_npv.append(self.index.mktprice_close() / init_index)
print(self.invst_portfolio.eval_date, ' close out ')
break
#移仓换月
self.invst_portfolio.shift_contract_month(self.account,
self.slippage)
self.account.daily_accounting(self.invst_portfolio.eval_date)
index_npv.append(self.index.mktprice_close() / init_index)
if not self.invst_portfolio.has_next(): break
self.invst_portfolio.next()
self.index.next()
self.account.account['baseindex_npv'] = index_npv
return self.account
df_cf = data.get_mktdata_future_daily(start_date, end_date, 'ih')
df_cf1 = data.get_mktdata_future_c1_daily(start_date, end_date, 'ih')
future = BaseFuture(df_cf1)
future.init()
futureset = BaseFutureSet(df_cf)
futureset.init()
account = BaseAccount(Util.MILLION * 10, rf=0)
print('Future Set Test')
contracts = futureset.eligible_futures
c_1 = futureset.select_higher_volume(contracts)
order = account.create_trade_order(c_1, LongShort.LONG, 10)
record = c_1.execute_order(order)
account.add_record(record, c_1)
while futureset.has_next():
if not c_1.has_next():
print(futureset.eval_date)
order = account.create_trade_order(c_1, LongShort.SHORT, 10)
record = c_1.execute_order(order)
account.add_record(record, c_1)
contracts = futureset.eligible_futures
c_1 = futureset.select_higher_volume(contracts)
print(c_1.id_instrument())
order = account.create_trade_order(c_1, LongShort.LONG, 10)
record = c_1.execute_order(order)
account.add_record(record, c_1)
account.daily_accounting(futureset.eval_date)
futureset.next()
class SytheticOption(object):
def __init__(self, df_index=None, df_future_c1=None, df_future_all=None):
if df_index is not None:
self.df_base = df_index
self.base = BaseInstrument(df_index)
else:
self.df_base = df_future_c1
self.base = BaseFutureCoutinuous(
df_future_c1=df_future_c1, df_futures_all_daily=df_future_all)
self.base.init()
self.account = BaseAccount(c.Util.BILLION * 10)
self._prepare_data()
self.leverage = 0.75 # Will be multiplied to delta equivalent position
self.rf = 0.03
self.slippage_date = 1 / 1000.0
self.hedge_multiplier = 1
self.hold_unit = 0
self.target_option = None
self.cd_model = 'ww' # Delta调仓模型
self.delta_criterian = 0.1 # 固定delta变化值调仓条件
self.delta_last_rebalanced = 0.0
self.ttm = 50 # 期权固定期限
self.k = 1.1 # 期权行权价比率
self.H = None
self.delta_upper_bound = 0.99
self.flag_fix_ttm = True
self.rho = 0.01
def _prepare_data(self):
days_1y = 252
days_6m = int(days_1y / 2)
days_3m = int(days_1y / 4)
# 前收盘历史已实现波动率
self.df_hv = self.df_base[[c.Util.DT_DATE]]
# self.df_hv['hv_1y'] = histvol.hist_vol(self.df_base[c.Util.AMT_CLOSE], n=days_1y)
self.df_hv['hv_6m'] = histvol.hist_vol(self.df_base[c.Util.AMT_CLOSE],
n=days_6m)
# self.df_hv['hv_3m'] = histvol.hist_vol(self.df_base[c.Util.AMT_CLOSE], n=days_3m)
self.df_hv = self.df_hv.dropna().set_index(c.Util.DT_DATE)
# self.df_hv.to_csv('df_hv.csv')
def update_target_option(self):
self.dt_maturity = self.base.eval_date + datetime.timedelta(
days=self.ttm)
self.strike = self.base.mktprice_close() * self.k
self.target_option = EuropeanOption(self.strike, self.dt_maturity,
c.OptionType.CALL)
def update_maturity(self):
self.dt_maturity = self.base.eval_date + datetime.timedelta(
days=self.ttm)
self.target_option = EuropeanOption(self.strike, self.dt_maturity,
c.OptionType.CALL)
def update_option_by_delta(self):
self.dt_maturity = self.base.eval_date + datetime.timedelta(
days=self.ttm)
spot = self.base.mktprice_close()
for k in np.arange(spot * 1.1, spot * 0.1, -spot / 30.0):
option = EuropeanOption(k, self.dt_maturity, c.OptionType.CALL)
delta = self.get_black_delta(option=option)
if delta >= self.delta_upper_bound:
self.strike = max(k, self.strike)
# self.strike = k
self.target_option = EuropeanOption(self.strike,
self.dt_maturity,
c.OptionType.CALL)
# print(self.base.eval_date,' update_option_by_delta')
return
def get_black_delta(self, vol: float = 0.2, option=None):
if option is None:
option = self.target_option
spot = self.base.mktprice_close()
date = self.base.eval_date
if date in self.df_hv.index:
vol = self.df_hv.loc[date, 'hv_6m']
else:
self.df_hv.loc[date, 'hv_6m'] = vol
self.vol = vol
black = BlackCalculator(self.ttm, option.strike, option.option_type,
spot, vol, self.rf)
delta = round(black.Delta(), 2)
return delta
def get_black_gamma(self, vol: float = 0.2):
spot = self.base.mktprice_close()
date = self.base.eval_date
if date in self.df_hv.index:
vol = self.df_hv.loc[date, 'hv_6m']
# print(vol)
black = BlackCalculator(self.ttm, self.target_option.strike,
self.target_option.option_type, spot, vol,
self.rf)
gamma = black.Gamma_1pct()
return gamma
# Equivalent Delta for Synthetic Option
def get_synthetic_delta(self, buywrite) -> float:
return buywrite.value * self.get_black_delta()
def rebalance_sythetic_long(self, delta) -> float:
if self.delta_bound_breaked(
delta) or self.delta_last_rebalanced == 0.0:
# d_delta = delta - self.delta_last_rebalanced
self.delta_last_rebalanced = delta
# return d_delta
return delta
else:
return 0.0
# May Add Delta Bound Models Here
def delta_bound_breaked(self, delta):
if self.cd_model == 'ww':
gamma = self.get_black_gamma()
self.H = self.whalley_wilmott(self.base.eval_date,
self.base.mktprice_close(), gamma,
self.dt_maturity)
if abs(delta - self.delta_last_rebalanced) > self.H:
return True
else:
return False
else:
if abs(delta - self.delta_last_rebalanced) > self.delta_criterian:
return True
else:
return False
def whalley_wilmott(self, eval_date, spot, gamma, dt_maturity):
fee = self.slippage_date
H = (1.5 * math.exp(-self.rf * self.ttm) * fee * spot * (gamma**2) /
self.rho)**(1 / 3)
return H
def close_out(self):
close_out_orders = self.account.creat_close_out_order(
cd_trade_price=c.CdTradePrice.CLOSE)
for order in close_out_orders:
execution_record = self.account.dict_holding[order.id_instrument] \
.execute_order(order, slippage_rate=self.slippage_date, execute_type=c.ExecuteType.EXECUTE_ALL_UNITS)
self.account.add_record(
execution_record,
self.account.dict_holding[order.id_instrument])
def excute(self, sythetic_delta):
if sythetic_delta == 0.0: return
sythetic_unit = np.floor(
(self.hold_unit * self.base.mktprice_close() + self.account.cash) *
sythetic_delta / self.base.mktprice_close())
unit = sythetic_unit - self.hold_unit
if unit > 0:
long_short = c.LongShort.LONG
max_unit = np.floor(self.account.cash * 0.99 /
self.base.mktprice_close())
unit = min(abs(unit), max_unit)
self.hold_unit += unit
else:
long_short = c.LongShort.SHORT
hold_unit = self.account.trade_book.loc[self.base.id_instrument(),
c.Util.TRADE_UNIT]
unit = min(abs(unit), hold_unit)
self.hold_unit -= unit
order = self.account.create_trade_order(self.base, long_short, unit)
record = self.base.execute_order(order,
slippage_rate=self.slippage_date)
self.account.add_record(record, self.base)
def back_test(self):
eval_year = self.base.eval_date.year
self.update_target_option(
) # Set Init Call Option with strike equals close price
init_close = self.base.mktprice_close()
self.account.daily_accounting(self.base.eval_date)
self.account.account.loc[
self.base.eval_date,
'benchmark'] = self.base.mktprice_close() / init_close
self.account.account.loc[self.base.eval_date,
'position_delta'] = self.delta_last_rebalanced
self.account.account.loc[self.base.eval_date,
'option_delta'] = self.get_black_delta()
self.account.account.loc[self.base.eval_date, 'ww_bound'] = self.H
self.account.account.loc[self.base.eval_date, 'strike'] = self.strike
self.account.account.loc[self.base.eval_date,
'gamma'] = self.get_black_gamma()
self.account.account.loc[self.base.eval_date, 'vol'] = None
self.base.next()
while self.base.current_index <= self.base.nbr_index - 1:
delta = self.get_synthetic_delta(c.BuyWrite.BUY)
self.excute(self.rebalance_sythetic_long(delta))
self.account.daily_accounting(self.base.eval_date)
self.account.account.loc[
self.base.eval_date,
'benchmark'] = self.base.mktprice_close() / init_close
self.account.account.loc[
self.base.eval_date,
'position_delta'] = self.delta_last_rebalanced
self.account.account.loc[self.base.eval_date,
'option_delta'] = self.get_black_delta()
self.account.account.loc[self.base.eval_date, 'ww_bound'] = self.H
self.account.account.loc[self.base.eval_date,
'strike'] = self.strike
self.account.account.loc[self.base.eval_date,
'gamma'] = self.get_black_gamma()
self.account.account.loc[self.base.eval_date,
'vol'] = self.df_hv.loc[
self.base.eval_date, 'hv_6m']
if not self.base.has_next():
return self.account
if self.base.next_date().year != eval_year:
eval_year = self.base.next_date().year
self.update_target_option(
) # Update option at last trading day of the year
elif self.delta_upper_bound is not None and self.delta_last_rebalanced >= self.delta_upper_bound:
self.update_option_by_delta()
self.base.next()
if self.flag_fix_ttm:
self.update_maturity()
return self.account
empty_position = True
unit_p = None
unit_c = None
atm_strike = None
buy_write = c.BuyWrite.WRITE
maturity1 = optionset.select_maturity_date(nbr_maturity=0, min_holding=20)
while optionset.eval_date <= end_date:
if account.cash <= 0: break
if maturity1 > end_date: # Final close out all.
close_out_orders = account.creat_close_out_order()
for order in close_out_orders:
execution_record = account.dict_holding[order.id_instrument].execute_order(order, slippage=0,
execute_type=c.ExecuteType.EXECUTE_ALL_UNITS)
account.add_record(execution_record, account.dict_holding[order.id_instrument])
account.daily_accounting(optionset.eval_date)
print(' close out ', optionset.eval_date,
account.account.loc[optionset.eval_date, c.Util.PORTFOLIO_NPV],
int(account.cash))
break
# 展期
if optionset.eval_date > maturity1 - datetime.timedelta(days=8):
close_out_orders = account.creat_close_out_order()
for order in close_out_orders:
execution_record = account.dict_holding[order.id_instrument].execute_order(order, slippage=0,
execute_type=c.ExecuteType.EXECUTE_ALL_UNITS)
account.add_record(execution_record, account.dict_holding[order.id_instrument])
empty_position = True
class HedgeIndexByOptions(object):
def __init__(self,
df_baseindex,
df_option_metrics,
df_c1=None,
df_all=None,
cd_direction_timing='ma',
cd_strategy='bull_spread',
cd_volatility='close_std',
cd_short_ma='ma_5',
cd_long_ma='ma_60',
cd_std='std_10'):
self.min_holding = 20
self.slippage = 0
self.nbr_maturity = 0
self.moneyness_rank = 0
self.cd_trade_price = c.CdTradePrice.VOLUME_WEIGHTED
# self.cd_trade_price = c.CdTradePrice.CLOSE
if df_c1 is None:
dt_start = max(df_option_metrics[c.Util.DT_DATE].values[0],
df_baseindex[c.Util.DT_DATE].values[0])
self.end_date = min(df_option_metrics[c.Util.DT_DATE].values[-1],
df_baseindex[c.Util.DT_DATE].values[-1])
df_metrics = df_option_metrics[
df_option_metrics[c.Util.DT_DATE] >= dt_start].reset_index(
drop=True)
df_baseindex = df_baseindex[
df_baseindex[c.Util.DT_DATE] >= dt_start].reset_index(
drop=True)
self.invst_portfolio = BaseInstrument(
df_baseindex) # e.g., top 50 low volatility index
self.invst_portfolio.init()
else:
dt_start = max(df_option_metrics[c.Util.DT_DATE].values[0],
df_baseindex[c.Util.DT_DATE].values[0],
df_c1[c.Util.DT_DATE].values[0])
self.end_date = min(df_option_metrics[c.Util.DT_DATE].values[-1],
df_baseindex[c.Util.DT_DATE].values[-1],
df_c1[c.Util.DT_DATE].values[-1])
df_metrics = df_option_metrics[
df_option_metrics[c.Util.DT_DATE] >= dt_start].reset_index(
drop=True)
df_baseindex = df_baseindex[
df_baseindex[c.Util.DT_DATE] >= dt_start].reset_index(
drop=True)
df_c1 = df_c1[df_c1[c.Util.DT_DATE] >= dt_start].reset_index(
drop=True)
df_all = df_all[df_all[c.Util.DT_DATE] >= dt_start].reset_index(
drop=True)
self.invst_portfolio = BaseFutureCoutinuous(
df_c1, df_futures_all_daily=df_all
) # e.g., top 50 low volatility index
self.invst_portfolio.init()
self.optionset = BaseOptionSet(df_metrics)
self.index = BaseInstrument(df_baseindex)
self.optionset.init()
self.index.init()
self.account = BaseAccount(init_fund=c.Util.BILLION,
leverage=1.0,
rf=0.03)
self.prepare_timing(df_baseindex)
self.cd_direction_timing = cd_direction_timing
self.cd_strategy = cd_strategy
self.cd_volatility = cd_volatility
self.cd_short_ma = cd_short_ma
self.cd_long_ma = cd_long_ma
self.cd_std = cd_std
self.dict_strategy = {}
self.nbr_timing = 0
self.nbr_stop_loss = 0
self.nvp_adjustment = 0
self.sl_npv_high_point = 1.0
self.strategy_pause = False
def prepare_timing(self, df_index):
df_index['ma_3'] = c.Statistics.moving_average(
df_index[c.Util.AMT_CLOSE], n=3).shift()
df_index['ma_5'] = c.Statistics.moving_average(
df_index[c.Util.AMT_CLOSE], n=5).shift()
df_index['ma_10'] = c.Statistics.moving_average(
df_index[c.Util.AMT_CLOSE], n=10).shift()
df_index['ma_15'] = c.Statistics.moving_average(
df_index[c.Util.AMT_CLOSE], n=15).shift()
df_index['ma_20'] = c.Statistics.moving_average(
df_index[c.Util.AMT_CLOSE], n=20).shift()
df_index['ma_30'] = c.Statistics.moving_average(
df_index[c.Util.AMT_CLOSE], n=30).shift()
df_index['ma_40'] = c.Statistics.moving_average(
df_index[c.Util.AMT_CLOSE], n=40).shift()
df_index['ma_50'] = c.Statistics.moving_average(
df_index[c.Util.AMT_CLOSE], n=50).shift()
df_index['ma_60'] = c.Statistics.moving_average(
df_index[c.Util.AMT_CLOSE], n=60).shift()
df_index['ma_120'] = c.Statistics.moving_average(
df_index[c.Util.AMT_CLOSE], n=120).shift()
df_index['std_5'] = c.Statistics.standard_deviation(
df_index[c.Util.AMT_CLOSE], n=5).shift()
df_index['std_10'] = c.Statistics.standard_deviation(
df_index[c.Util.AMT_CLOSE], n=10).shift()
df_index['std_15'] = c.Statistics.standard_deviation(
df_index[c.Util.AMT_CLOSE], n=15).shift()
df_index['std_20'] = c.Statistics.standard_deviation(
df_index[c.Util.AMT_CLOSE], n=20).shift()
df_index['ma_3-20'] = df_index['ma_3'] - df_index['ma_20']
self.df_timing = df_index.set_index(c.Util.DT_DATE)
def open_signal(self):
if self.cd_direction_timing == 'ma':
return self.open_position_ma()
def close_signal(self):
if self.cd_direction_timing == 'ma':
return self.close_position_ma()
def stop_loss_beg(self, drawdown, P_mdd):
if drawdown.loc[self.optionset.eval_date, c.Util.DRAWDOWN] <= P_mdd:
return True
def stop_loss_end(self, drawdown, P_mdd):
if drawdown.loc[
self.optionset.eval_date,
c.Util.PORTFOLIO_NPV] >= self.account.account[
c.Util.PORTFOLIO_NPV].values[-1] + self.nvp_adjustment:
self.nvp_adjustment = drawdown.loc[
self.optionset.eval_date,
c.Util.PORTFOLIO_NPV] - self.account.account[
c.Util.PORTFOLIO_NPV].values[-1]
self.nbr_stop_loss += 1
print(self.optionset.eval_date, ' stop loss end ')
print(self.nvp_adjustment,
self.account.account[c.Util.PORTFOLIO_NPV].values[-1],
drawdown.loc[self.optionset.eval_date, c.Util.PORTFOLIO_NPV])
return True
def strategy(self, cd_price=c.CdPriceType.OPEN):
if self.cd_strategy == 'bull_spread':
if self.cd_volatility == 'close_std':
dt_date = self.optionset.eval_date
std_close = self.df_timing.loc[dt_date, self.cd_std]
k_short = self.index.mktprice_open() - std_close
put_long, put_short = self.bull_spread(k_short, cd_price)
return {
c.LongShort.SHORT: put_short,
c.LongShort.LONG: put_long
}
def shift(self):
if self.cd_strategy == 'bull_spread':
return self.shift_bull_spread()
def open_position_ma(self):
dt_date = self.optionset.eval_date
if dt_date not in self.df_timing.index:
return False
ma_5 = self.df_timing.loc[dt_date, self.cd_short_ma]
ma_60 = self.df_timing.loc[dt_date, self.cd_long_ma]
if ma_5 < ma_60:
return True
else:
return False
def close_position_ma(self):
dt_date = self.optionset.eval_date
dt_maturity = None
for option in self.account.dict_holding.values():
if isinstance(option, BaseOption) and option is not None:
dt_maturity = option.maturitydt()
break
if dt_maturity is not None and (dt_maturity - dt_date).days <= 5:
return True
ma_5 = self.df_timing.loc[dt_date, self.cd_short_ma]
ma_60 = self.df_timing.loc[dt_date, self.cd_long_ma]
if ma_5 >= ma_60:
print(self.optionset.eval_date)
self.nbr_timing += 1
return True
else:
return False
def bull_spread(self, k_short, cd_price=c.CdPriceType.OPEN):
maturity = self.optionset.select_maturity_date(
nbr_maturity=self.nbr_maturity, min_holding=self.min_holding)
xx, list_put0 = self.optionset.get_options_list_by_moneyness_mthd1(
moneyness_rank=self.moneyness_rank,
maturity=maturity,
cd_price=cd_price)
put_long = self.optionset.select_higher_volume(list_put0)
# if put_long is None:
# xxx, list_put0 = optionset.get_options_list_by_moneyness_mthd1(moneyness_rank=0,
# maturity=maturity,
# cd_price=c.CdPriceType.OPEN)
# put_long = optionset.select_higher_volume(list_put0)
put_short = self.optionset.select_higher_volume(
self.optionset.get_option_closest_strike(c.OptionType.PUT, k_short,
maturity))
if put_short is not None:
if put_short.strike() >= (k_short + put_long.strike()) / 2.0:
put_short = None
elif put_short.id_instrument() == put_long.id_instrument():
xx, list_put1 = self.optionset.get_options_list_by_moneyness_mthd1(
moneyness_rank=-1, maturity=maturity, cd_price=cd_price)
put_short = self.optionset.select_higher_volume(list_put1)
# put_short = None
return put_long, put_short
def shift_bull_spread(self):
option_short = self.dict_strategy[c.LongShort.SHORT]
option_long = self.dict_strategy[c.LongShort.LONG]
if option_short is None:
return self.strategy()
else:
if self.index.mktprice_last_close() <= (option_long.strike() +
option_short.strike()) / 2:
return self.strategy()
else:
return None
def excute(self, dict_strategy, cd_trade_price=None):
if cd_trade_price is None:
cd_trade_price = self.cd_trade_price
if dict_strategy is None: return
for long_short in dict_strategy.keys():
option = dict_strategy[long_short]
if option is None:
continue
elif long_short in self.dict_strategy.keys() and self.dict_strategy[long_short] is not None \
and option.id_instrument() == self.dict_strategy[long_short].id_instrument():
continue
unit = self.unit_index / option.multiplier()
order = self.account.create_trade_order(
option, long_short, unit, cd_trade_price=cd_trade_price)
record = option.execute_order(order, slippage=self.slippage)
self.account.add_record(record, option)
self.dict_strategy = dict_strategy
def close_options(self):
for option in self.account.dict_holding.values():
if isinstance(option, BaseOption):
order = self.account.create_close_order(
option, cd_trade_price=self.cd_trade_price)
record = option.execute_order(order, slippage=self.slippage)
self.account.add_record(record, option)
self.dict_strategy = {}
def close_out(self):
close_out_orders = self.account.creat_close_out_order(
cd_trade_price=c.CdTradePrice.CLOSE)
for order in close_out_orders:
execution_record = self.account.dict_holding[order.id_instrument] \
.execute_order(order, slippage=self.slippage, execute_type=c.ExecuteType.EXECUTE_ALL_UNITS)
self.account.add_record(
execution_record,
self.account.dict_holding[order.id_instrument])
def back_test(self):
self.unit_index = np.floor(self.account.cash /
self.index.mktprice_close() /
self.index.multiplier())
unit_portfolio = np.floor(self.account.cash /
self.invst_portfolio.mktprice_close() /
self.invst_portfolio.multiplier())
order_index = self.account.create_trade_order(
self.invst_portfolio,
c.LongShort.LONG,
unit_portfolio,
cd_trade_price=c.CdTradePrice.CLOSE)
record_index = self.invst_portfolio.execute_order(
order_index, slippage=self.slippage)
self.account.add_record(record_index, self.invst_portfolio)
empty_position = True
init_index = self.index.mktprice_close()
init_portfolio = self.invst_portfolio.mktprice_close()
base_npv = []
index_npv = []
while self.optionset.eval_date <= self.end_date:
# if self.optionset.eval_date == datetime.date(2016,5,20):
# print('')
# print(self.optionset.eval_date)
if self.optionset.eval_date >= self.end_date: # Final close out all.
close_out_orders = self.account.creat_close_out_order()
for order in close_out_orders:
execution_record = self.account.dict_holding[order.id_instrument] \
.execute_order(order, slippage=self.slippage, execute_type=c.ExecuteType.EXECUTE_ALL_UNITS)
self.account.add_record(
execution_record,
self.account.dict_holding[order.id_instrument])
self.account.daily_accounting(self.optionset.eval_date)
base_npv.append(self.invst_portfolio.mktprice_close() /
init_portfolio)
index_npv.append(self.index.mktprice_close() / init_index)
print(self.optionset.eval_date, ' close out ')
break
if not empty_position:
if self.close_signal():
self.close_options()
empty_position = True
else:
strategy = self.shift()
if strategy is not None:
self.close_options()
self.excute(strategy)
if empty_position and self.open_signal():
self.excute(self.strategy())
empty_position = False
#TODO:移仓换月
if isinstance(self.invst_portfolio, BaseFutureCoutinuous):
self.invst_portfolio.shift_contract_month(
self.account, self.slippage)
self.account.daily_accounting(self.optionset.eval_date)
self.account.account.loc[self.optionset.eval_date,
'unit_index'] = self.unit_index
self.account.account.loc[
self.optionset.eval_date,
'close_index'] = self.index.mktprice_close()
# print(self.optionset.eval_date,estimated_npv1,estimated_npv2,estimated_npv3,self.account.account.loc[self.optionset.eval_date,c.Util.PORTFOLIO_NPV])
base_npv.append(self.invst_portfolio.mktprice_close() /
init_portfolio)
index_npv.append(self.index.mktprice_close() / init_index)
# print(self.invst_portfolio.eval_date, self.account.account.loc[self.optionset.eval_date,c.Util.PORTFOLIO_NPV],
# self.invst_portfolio.mktprice_close() / init_index)
if not self.optionset.has_next(): break
self.optionset.next()
self.index.next()
self.invst_portfolio.next()
self.account.account['base_npv'] = base_npv
self.account.account['index_npv'] = index_npv
# active_npv = self.df_index[self.df_index[c.Util.DT_DATE]<=self.optionset.eval_date].reset_index(drop=True)
# self.account.account['active_npv'] = active_npv[c.Util.AMT_CLOSE]
self.account.nbr_timing = self.nbr_timing
# print(self.account.account.loc[self.invst_portfolio.eval_date,c.Util.PORTFOLIO_NPV])
return self.account
def back_test_with_stop_loss(self, drawdown, P_mdd):
self.P_mdd = P_mdd
self.unit_index = np.floor(self.account.cash /
self.index.mktprice_close() /
self.index.multiplier())
order_index = self.account.create_trade_order(
self.index,
c.LongShort.LONG,
self.unit_index,
cd_trade_price=c.CdTradePrice.CLOSE)
record_index = self.index.execute_order(order_index,
slippage=self.slippage)
self.account.add_record(record_index, self.index)
empty_position = True
init_index = self.index.mktprice_close()
base_npv = []
stop_loss_paused = False
while self.optionset.eval_date <= self.end_date:
# if self.optionset.eval_date == datetime.date(2016,5,20):
# print('')
# print(self.optionset.eval_date)
if self.optionset.eval_date >= self.end_date: # Final close out all.
close_out_orders = self.account.creat_close_out_order()
for order in close_out_orders:
execution_record = self.account.dict_holding[order.id_instrument] \
.execute_order(order, slippage=self.slippage, execute_type=c.ExecuteType.EXECUTE_ALL_UNITS)
self.account.add_record(
execution_record,
self.account.dict_holding[order.id_instrument])
self.account.daily_accounting(self.optionset.eval_date)
base_npv.append(self.index.mktprice_close() / init_index)
print(self.optionset.eval_date, ' close out ')
break
# Option Hedge
if not stop_loss_paused:
if not empty_position:
if self.close_signal():
self.close_all_options()
empty_position = True
else:
strategy = self.shift()
if strategy is not None:
self.close_all_options()
self.excute(strategy)
if empty_position and self.open_signal():
self.excute(self.strategy())
empty_position = False
estimated_npv = self.account.estimate_npv()
self.sl_npv_high_point = max(self.sl_npv_high_point, estimated_npv)
# if self.account.account.loc[self.optionset.eval_date, c.Util.DRAWDOWN]>= 0.0:
# self.P_mdd = P_mdd
# 止损控制
if (estimated_npv - self.sl_npv_high_point
) / self.sl_npv_high_point < self.P_mdd:
self.close_out()
self.sl_npv_high_point = estimated_npv
self.strategy_npv_paused = drawdown.loc[
self.optionset.eval_date, c.Util.PORTFOLIO_NPV]
print(self.optionset.eval_date, 'stop loss',
self.sl_npv_high_point, self.P_mdd)
self.account.daily_accounting(self.optionset.eval_date, False)
base_npv.append(self.index.mktprice_close() / init_index)
if not self.optionset.has_next(): break
self.optionset.next()
self.index.next()
stop_loss_paused = True
empty_position = True
# self.P_mdd = -0.02
continue
if stop_loss_paused:
strategy_npv = drawdown.loc[self.optionset.eval_date,
c.Util.PORTFOLIO_NPV]
# 止损后空仓
# if strategy_npv <= self.strategy_npv_paused:
if (strategy_npv - self.strategy_npv_paused
) / self.strategy_npv_paused < 0.01:
self.account.daily_accounting(self.optionset.eval_date)
base_npv.append(self.index.mktprice_close() / init_index)
if not self.optionset.has_next(): break
self.optionset.next()
self.index.next()
continue
# 止损信号解除
else:
order_index = self.account.create_trade_order(
self.index,
c.LongShort.LONG,
self.unit_index,
cd_trade_price=c.CdTradePrice.CLOSE)
record_index = self.index.execute_order(
order_index, slippage=self.slippage)
self.account.add_record(record_index, self.index)
stop_loss_paused = False
self.nbr_stop_loss += 1
print(self.optionset.eval_date, 'stop loss end')
# if empty_position and self.open_signal():
# self.excute(self.strategy(cd_price=c.CdPriceType.CLOSE),cd_trade_price=c.CdTradePrice.CLOSE)
# empty_position = False
# 每日结算
self.account.daily_accounting(self.optionset.eval_date)
base_npv.append(self.index.mktprice_close() / init_index)
if not self.optionset.has_next(): break
self.optionset.next()
self.index.next()
self.account.account['base_npv'] = base_npv
# active_npv = self.df_index[self.df_index[c.Util.DT_DATE] <= self.optionset.eval_date].reset_index(drop=True)
# self.account.account['active_npv'] = active_npv[c.Util.AMT_CLOSE]
self.account.nbr_timing = self.nbr_timing
self.account.nbr_stop_loss = self.nbr_stop_loss
return self.account
baseoption2._reprocess_if_genenate_single_option()
baseoption1.init()
baseoption2.init()
baseoption1.go_to(dt_open)
baseoption2.go_to(dt_open)
long_short = c.LongShort.SHORT
margin_capital1 = baseoption1.get_initial_margin(long_short)
margin_capital2 = baseoption2.get_initial_margin(long_short)
unit_c = np.floor(np.floor(account.portfolio_total_value*m / (margin_capital1+margin_capital2)))
order_c = account.create_trade_order(baseoption1, long_short, unit_c, cd_trade_price=cd_trade_price)
order_p = account.create_trade_order(baseoption2, long_short, unit_c, cd_trade_price=cd_trade_price)
record_call = baseoption1.execute_order(order_c, slippage=0)
record_put = baseoption2.execute_order(order_p, slippage=0)
account.add_record(record_call, baseoption1)
account.add_record(record_put, baseoption2)
while not baseoption1.is_last():
account.daily_accounting(baseoption1.eval_date)
baseoption1.next()
baseoption2.next()
# account.account.to_csv('cu_daily_report_npv.csv')
# account.trade_records.to_csv('cu_daily_report_trade_records.csv')
dates = list(account.account.index)
npv = list(account.account[c.Util.PORTFOLIO_NPV])
print(account.analysis())
pu = PlotUtil()
pu.plot_line_chart(dates,[npv],['npv'])
plt.show()
class SyntheticOptionHedgedPortfolio():
def __init__(self, start_date, end_date):
self.ttm = 30
self.buywrite = BuyWrite.BUY
self.fund = Util.BILLION
self.invest_underlying_ratio = 0.7
# self.invest_underlying_ratio = 1
self.slippage = 2
self.start_date = start_date
self.end_date = end_date
hist_date = start_date - datetime.timedelta(days=40)
df_future_c1 = get_dzqh_cf_c1_minute(start_date, end_date, 'if')
df_future_c1_daily = get_dzqh_cf_c1_daily(hist_date, end_date, 'if')
df_futures_all_daily = get_dzqh_cf_daily(
start_date, end_date, 'if') # daily data of all future contracts
df_index = get_index_mktdata(
start_date, end_date,
'index_300sh') # daily data of underlying index
df_index = df_index[df_index[Util.DT_DATE].isin(
Util.DZQH_CF_DATA_MISSING_DATES) == False].reset_index(drop=True)
# df_index.to_csv('df_index.csv')
self.trade_dates = sorted(df_future_c1_daily[Util.DT_DATE].unique())
self.df_vol_1m = Histvol.hist_vol(df_future_c1_daily)
# df_parkinson_1m = Histvol.parkinson_number(df_future_c1_daily)
self.df_garman_klass = Histvol.garman_klass(df_future_c1_daily)
# df_hist_vol = self.df_vol_1m.join(self.df_garman_klass, how='left')
# df_hist_vol.to_csv('../../data/df_hist_vol.csv')
self.underlying = BaseInstrument(df_data=df_index)
self.underlying.init()
self.synthetic_option = SytheticOption(
df_c1_data=df_future_c1,
# df_c1_daily=df_future_c1_daily,
df_futures_all_daily=df_futures_all_daily,
df_index_daily=df_index)
self.synthetic_option.init()
self.account = BaseAccount(self.fund, leverage=20.0, rf=0.0)
self.trading_desk = Trade()
self.init_spot = self.synthetic_option.underlying_state_daily[
Util.AMT_CLOSE]
self.df_analysis = pd.DataFrame()
def next(self):
if self.synthetic_option.is_last_minute():
self.underlying.next()
self.synthetic_option.next()
def init_portfolio(self, fund):
""" Init position """
dt_maturity = self.synthetic_option.eval_date + datetime.timedelta(
days=self.ttm)
# strike = self.underlying.mktprice_close()
strike = self.synthetic_option.mktprice_close()
# dt_maturity = self.synthetic_option.eval_date + datetime.timedelta(days=30)
self.Option = EuropeanOption(strike, dt_maturity, OptionType.PUT)
# self.Option = EuropeanOption(strike, dt_maturity, OptionType.CALL)
""" 用第一天的日收盘价开仓标的现货多头头寸 """
underlying_unit = np.floor(fund * self.invest_underlying_ratio /
self.underlying.mktprice_close())
order_underlying = self.account.create_trade_order(
self.underlying, LongShort.LONG, underlying_unit)
execution_record = self.underlying.execute_order(
order_underlying,
slippage=0,
execute_type=ExecuteType.EXECUTE_ALL_UNITS)
self.account.add_record(execution_record, self.underlying)
self.synthetic_option.amt_option = underlying_unit
""" 用第一天的成交量加权均价开仓/调整复制期权头寸 """
vol = self.get_vol()
self.delta = self.synthetic_option.get_black_delta(self.Option, vol)
synthetic_unit = self.synthetic_option.get_synthetic_unit(
self.delta, self.buywrite)
self.synthetic_option.synthetic_unit = synthetic_unit
if synthetic_unit > 0:
long_short = LongShort.LONG
else:
long_short = LongShort.SHORT
order = self.account.create_trade_order(self.synthetic_option,
long_short, synthetic_unit)
execution_record = self.synthetic_option.execute_order_by_VWAP(
order, slippage=0, execute_type=ExecuteType.EXECUTE_ALL_UNITS)
self.account.add_record(execution_record, self.synthetic_option)
self.account.daily_accounting(self.synthetic_option.eval_date)
self.add_additional_to_account()
self.disp()
self.next()
def rebalance_sythetic_option(self):
""" Reset and Rebalance sythetic option """
dt_maturity = self.synthetic_option.eval_date + datetime.timedelta(
days=self.ttm)
# strike = self.underlying.mktprice_close()
strike = self.synthetic_option.mktprice_close()
self.Option = EuropeanOption(strike, dt_maturity, OptionType.PUT)
# self.Option = EuropeanOption(strike, dt_maturity, OptionType.CALL)
""" 用成交量加权均价调整复制期权头寸 """
vol = self.get_vol()
self.delta = self.synthetic_option.get_black_delta(self.Option, vol)
synthetic_unit = self.synthetic_option.get_rebalancing_unit(
self.delta, self.Option, vol,
self.synthetic_option.mktprice_close(), DeltaBound.NONE,
self.buywrite)
self.synthetic_option.synthetic_unit += synthetic_unit
if synthetic_unit > 0:
long_short = LongShort.LONG
else:
long_short = LongShort.SHORT
order = self.account.create_trade_order(self.synthetic_option,
long_short, synthetic_unit)
execution_record = self.synthetic_option.execute_order_by_VWAP(
order, slippage=0, execute_type=ExecuteType.EXECUTE_ALL_UNITS)
self.account.add_record(execution_record, self.synthetic_option)
self.account.daily_accounting(self.synthetic_option.eval_date)
self.add_additional_to_account()
self.disp()
self.next()
return
def hedge(self, dt_end=None):
id_future = self.synthetic_option.current_state[Util.ID_INSTRUMENT]
if dt_end is None:
dt_end = self.Option.dt_maturity
dt_time_end = datetime.datetime(dt_end.year, dt_end.month, dt_end.day,
15, 00, 0)
while self.synthetic_option.has_next(
) and self.synthetic_option.eval_datetime <= dt_time_end:
if id_future != self.synthetic_option.current_state[
Util.ID_INSTRUMENT]:
long_short = self.account.trade_book.loc[id_future,
Util.TRADE_LONG_SHORT]
hold_unit = -self.account.trade_book.loc[id_future,
Util.TRADE_UNIT]
spot = self.synthetic_option.mktprice_close()
vol = self.get_vol()
self.delta = self.synthetic_option.get_black_delta(
self.Option, vol, spot)
synthetic_unit = self.synthetic_option.get_synthetic_unit(
self.delta, self.buywrite) # 按照移仓换月日的收盘价计算Delta
id_c2 = self.synthetic_option.current_state[Util.ID_INSTRUMENT]
open_unit = synthetic_unit
self.synthetic_option.synthetic_unit += open_unit - hold_unit
close_execution_record, open_execution_record \
= self.synthetic_option.shift_contract_by_VWAP(id_c1=id_future,
id_c2=id_c2,
hold_unit=hold_unit,
open_unit=open_unit,
long_short=long_short,
slippage=self.slippage,
execute_type=ExecuteType.EXECUTE_ALL_UNITS
)
self.account.add_record(close_execution_record,
self.synthetic_option)
self.synthetic_option._id_instrument = id_c2
self.account.add_record(open_execution_record,
self.synthetic_option)
""" 更新当前持仓头寸 """
""" USE SAME UNIT TO SHIFT CONTRACT AND USE CLOSE PRICE TO REBALANCING DELTA CHANGE. """
print(' Relancing after shift contract, ',
self.synthetic_option.eval_date)
id_future = id_c2
if self.synthetic_option.eval_datetime.time() == datetime.time(
9, 30, 0):
self.next()
if self.synthetic_option.eval_date == self.synthetic_option.get_next_state_date(
):
if not self.if_hedge('5min'):
self.next()
continue
self.rebalancing()
if self.synthetic_option.is_last_minute():
self.account.daily_accounting(
self.synthetic_option.eval_date) # 该日的收盘结算
self.add_additional_to_account()
self.disp()
if self.synthetic_option.eval_date == dt_end and self.synthetic_option.is_last_minute(
):
self.close_out()
self.next()
def if_hedge(self, cd):
if cd == '1h':
""" 1h """
if self.synthetic_option.eval_datetime.minute == 0:
return True
else:
return False
elif cd == '10min':
""" 10min """
if self.synthetic_option.eval_datetime.minute % 10 == 0:
return True
else:
return False
elif cd == '5min':
""" 5min """
if self.synthetic_option.eval_datetime.minute % 5 == 0:
return True
else:
return False
elif cd == '1min':
return True
elif cd == 'half_day':
if self.synthetic_option.eval_datetime.time() == datetime.time(11, 29, 00) or \
self.synthetic_option.eval_datetime.time() == datetime.time(14, 59, 00):
return True
else:
return False
def rebalancing(self):
vol = self.get_vol()
self.delta = self.synthetic_option.get_black_delta(self.Option, vol)
rebalance_unit = self.synthetic_option.get_rebalancing_unit(
self.delta, self.Option, vol,
self.synthetic_option.mktprice_close(),
DeltaBound.WHALLEY_WILLMOTT, self.buywrite)
self.synthetic_option.synthetic_unit += rebalance_unit
if rebalance_unit > 0:
long_short = LongShort.LONG
else:
long_short = LongShort.SHORT
order = self.account.create_trade_order(self.synthetic_option,
long_short, rebalance_unit)
execution_record = self.synthetic_option.execute_order(
order,
slippage=self.slippage,
execute_type=ExecuteType.EXECUTE_ALL_UNITS)
self.account.add_record(execution_record, self.synthetic_option)
def close_out(self):
while not self.synthetic_option.is_last_minute():
self.next()
close_out_orders = self.account.creat_close_out_order()
for order in close_out_orders:
execution_record = self.account.dict_holding[
order.id_instrument].execute_order(
order,
slippage=0,
execute_type=ExecuteType.EXECUTE_ALL_UNITS)
self.account.add_record(
execution_record,
self.account.dict_holding[order.id_instrument])
self.account.daily_accounting(self.synthetic_option.eval_date)
self.add_additional_to_account()
self.disp()
self.synthetic_option.sythetic_unit = 0
""" Final NPV check """
self.df_records = pd.DataFrame(self.account.list_records)
total_pnl = self.df_records[Util.TRADE_REALIZED_PNL].sum()
final_npv = (self.fund + total_pnl) / self.fund
print('calculate final npv from adding up realized pnl ; ', final_npv)
def get_vol(self):
date = self.synthetic_option.eval_date
if date in self.df_vol_1m.index:
# vol = self.df_vol_1m.loc[date, Util.AMT_HISTVOL]
vol = self.df_garman_klass.loc[self.synthetic_option.eval_date,
Util.AMT_GARMAN_KLASS]
else:
dt1 = Util.largest_element_less_than(port.trade_dates, date)
vol = self.df_garman_klass.loc[dt1, Util.AMT_GARMAN_KLASS]
# vol = self.df_vol_1m.loc[dt1, Util.AMT_HISTVOL]
return vol
def add_additional_to_account(self):
# self.account.account.loc[
# self.synthetic_option.eval_date, 'underlying_npv_1'] = self.invest_underlying_ratio * self.underlying.mktprice_close() / self.init_spot + 1 - self.invest_underlying_ratio
self.account.account.loc[
self.synthetic_option.eval_date,
'underlying_npv'] = self.underlying.mktprice_close(
) / self.init_spot
self.account.account.loc[
self.synthetic_option.eval_date,
'underlying_price'] = self.underlying.mktprice_close()
self.account.account.loc[
self.synthetic_option.eval_date,
'if_c1'] = self.synthetic_option.mktprice_close()
self.account.account.loc[self.synthetic_option.eval_date, 'hedge_position'] \
= - self.account.trade_book[self.account.trade_book[Util.TRADE_LONG_SHORT] == LongShort.SHORT][
Util.TRADE_UNIT].sum()
self.account.account.loc[self.synthetic_option.eval_date, 'hedge_ratio'] = \
self.account.account.loc[self.synthetic_option.eval_date, Util.PORTFOLIO_SHORT_POSITION_SCALE] / \
self.account.account.loc[self.synthetic_option.eval_date, Util.PORTFOLIO_LONG_POSITION_SCALE]
self.account.account.loc[self.synthetic_option.eval_date, 'pct_margin_unrealized_pnl'] = \
self.account.account.loc[
self.synthetic_option.eval_date, Util.MARGIN_UNREALIZED_PNL] / self.account.init_fund
self.account.account.loc[self.synthetic_option.eval_date, 'pct_nonmargin_unrealized_pnl'] = \
self.account.account.loc[
self.synthetic_option.eval_date, Util.NONMARGIN_UNREALIZED_PNL] / self.account.init_fund
self.account.account.loc[self.synthetic_option.eval_date, 'pct_realized_pnl'] = \
self.account.account.loc[self.synthetic_option.eval_date, Util.TRADE_REALIZED_PNL] / self.account.init_fund
self.account.account.loc[self.synthetic_option.eval_date,
'delta'] = self.delta
def save_results(self):
self.df_records.to_csv('../../data/trade_records.csv')
self.account.account.to_csv('../../data/account.csv')
# self.df_hedge_info = pd.DataFrame(self.list_hedge_info)
# self.df_hedge_info.to_csv('../../data/hedge_info.csv')
self.df_analysis.to_csv('../../data/df_analysis.csv')
self.account.trade_book_daily.to_csv('../../data/trade_book_daily.csv')
def disp(self):
if self.synthetic_option.eval_date != self.underlying.eval_date:
print('Date miss matched!')
try:
average_cost = int(self.account.trade_book[self.account.trade_book[
Util.TRADE_LONG_SHORT] == LongShort.SHORT][
Util.AVERAGE_POSITION_COST].values[0])
except:
average_cost = 0
pass
print(
self.synthetic_option.eval_datetime,
self.account.account.loc[self.synthetic_option.eval_date,
Util.PORTFOLIO_NPV],
self.underlying.mktprice_close() / self.init_spot,
# self.account.account.loc[self.synthetic_option.eval_date, 'hedge_position'],
# self.synthetic_option.synthetic_unit,
int(self.Option.strike),
int(self.underlying.mktprice_close()),
int(self.synthetic_option.mktprice_close()),
average_cost,
round(self.delta, 2),
round(
self.account.account.loc[self.synthetic_option.eval_date,
'hedge_ratio'], 2),
# self.account.cash,
round(
100 * self.account.account.loc[self.synthetic_option.eval_date,
'pct_margin_unrealized_pnl'],
1),
'%',
round(
100 * self.account.account.loc[self.synthetic_option.eval_date,
'pct_nonmargin_unrealized_pnl'],
1),
'%',
round(
100 * self.account.account.loc[self.synthetic_option.eval_date,
'pct_realized_pnl'], 1),
'%',
self.underlying.eval_date,
)
def reset_option_maturity(self, dt_maturity=None):
if dt_maturity is None:
dt_maturity = self.synthetic_option.eval_date + datetime.timedelta(
days=self.ttm)
self.Option.dt_maturity = dt_maturity
def reset_option_strike(self):
strike = self.synthetic_option.mktprice_close()
self.Option.strike = strike
def analysis(self, dt_start, dt_end):
""" Replicate Period Result Analysis """
self.df_records = pd.DataFrame(self.account.list_records)
analysis = pd.Series()
df_hedge_records = self.df_records[
(self.df_records[Util.ID_INSTRUMENT] != 'index_300sh')
& (self.df_records[Util.DT_TRADE] >= dt_start) &
(self.df_records[Util.DT_TRADE] <= dt_end)]
init_stock_value = self.account.account.loc[
dt_start, Util.PORTFOLIO_TRADES_VALUE]
init_stock_price = \
self.underlying.df_data[self.underlying.df_data[Util.DT_DATE] == dt_start][Util.AMT_CLOSE].values[0]
terminal_stock_price = \
self.underlying.df_data[self.underlying.df_data[Util.DT_DATE] == dt_end][Util.AMT_CLOSE].values[0]
replicate_pnl = df_hedge_records[Util.TRADE_REALIZED_PNL].sum()
option_payoff = self.synthetic_option.amt_option * max(
init_stock_price - terminal_stock_price, 0)
replicate_cost = replicate_pnl - option_payoff
replicate_cost_future = replicate_pnl - self.synthetic_option.amt_option * max(
self.Option.strike - terminal_stock_price, 0)
pct_replicate_cost = replicate_cost / init_stock_value
pct_replicate_pnl = replicate_pnl / init_stock_value
transaction_cost = df_hedge_records[Util.TRANSACTION_COST].sum()
init_portfolio_value = self.account.account.loc[dt_start,
Util.PORTFOLIO_VALUE]
trade_value = np.abs(df_hedge_records[Util.TRADE_BOOK_VALUE]).sum()
ratio = trade_value / init_portfolio_value
pct_underlying_pnl = (terminal_stock_price -
init_stock_price) / init_stock_price
analysis['ratio'] = ratio
analysis['dt_start'] = dt_start
analysis['dt_end'] = dt_end
analysis['init_stock_value'] = init_stock_value
analysis['replicate_pnl'] = replicate_pnl
analysis['option_payoff'] = option_payoff
analysis['replicate_cost_spot'] = replicate_cost
analysis['replicate_cost_future'] = replicate_cost_future
analysis['pct_replicate_cost'] = pct_replicate_cost
analysis['pct_replicate_pnl'] = pct_replicate_pnl
analysis['pct_underlying_pnl'] = pct_underlying_pnl
analysis['transaction_cost'] = transaction_cost
analysis['dt_maturity'] = self.Option.dt_maturity
self.df_analysis = self.df_analysis.append(analysis, ignore_index=True)
# index = BaseInstrument(df_index_metrics)
df_cf_minute = get_dzqh_cf_minute(start_date, end_date, 'if')
df_cf = get_dzqh_cf_daily(start_date, end_date, 'if')
future = BaseFutureCoutinuous(df_cf_minute,
df_cf,
frequency=FrequentType.MINUTE)
future.init()
account = BaseAccount(Util.BILLION)
trading_desk = Trade()
# while future.has_next():
# for option in option_set.eligible_options:
# TODO: Create and execute order could be implemented in base_product class.
order = account.create_trade_order(future, TradeType.OPEN_LONG, 10)
execution_res = future.execute_order(order)
account.add_record(execution_res, future)
trading_desk.add_pending_order(order)
future.next()
order = account.create_trade_order(future, TradeType.OPEN_SHORT, 5)
execution_res = future.execute_order(order)
account.add_record(execution_res, future)
trading_desk.add_pending_order(order)
future.next()
order = account.create_trade_order(future, TradeType.OPEN_SHORT, 10)
execution_res = future.execute_order(order)
account.add_record(execution_res, future)
trading_desk.add_pending_order(order)
future.next()
account.daily_accounting(future.eval_date)
class NakedShort(object):
def __init__(self,
df_metrics,
df_baseindex=None,
cd_strategy='naked_put',
id_baseindex=c.Util.STR_INDEX_300SH,
cd_marutity_days=3):
self.start_date = df_metrics[c.Util.DT_DATE].values[0]
self.end_date = df_metrics[c.Util.DT_DATE].values[-1]
if df_baseindex is None:
df_baseindex = get_data.get_index_mktdata(self.start_date,
self.end_date,
c.Util.STR_INDEX_300SH)
self.min_holding = 20
self.init_fund = c.Util.BILLION
self.slippage = 0
self.m = 1 # 期权notional倍数
if cd_strategy == 'short_straddle':
self.m = 0.5
self.moneyness_rank = -4
self.nbr_maturity = 0
self.cd_trade_price = c.CdTradePrice.VOLUME_WEIGHTED
self.account = BaseAccount(init_fund=c.Util.BILLION,
leverage=1.0,
rf=0.03)
self.optionset = BaseOptionSet(df_metrics)
self.optionset.init()
self.index = BaseInstrument(df_baseindex)
self.index.init()
self.cd_strategy = cd_strategy
self.cd_maturity_days = cd_marutity_days
self.init_index = self.index.mktprice_close()
# w.start()
# TODO: 统一 check dt_first; 将base_npv写入accout
def close_signal(self):
dt_maturity = None
for option in self.account.dict_holding.values():
if isinstance(option, BaseOption) and option is not None:
dt_maturity = option.maturitydt()
break
# t = w.tdayscount(self.optionset.eval_date.strftime("%Y-%m-%d"), dt_maturity.strftime("%Y-%m-%d"), "").Data[0][0]
t = c.QuantlibUtil.get_business_between(self.optionset.eval_date,
dt_maturity)
if t <= self.cd_maturity_days:
# if (dt_maturity - self.optionset.eval_date).days <= self.cd_maturity_days:
return True
else:
return False
def close_out(self):
close_out_orders = self.account.creat_close_out_order(
cd_trade_price=c.CdTradePrice.CLOSE)
for order in close_out_orders:
execution_record = self.account.dict_holding[order.id_instrument] \
.execute_order(order, slippage=self.slippage, execute_type=c.ExecuteType.EXECUTE_ALL_UNITS)
self.account.add_record(
execution_record,
self.account.dict_holding[order.id_instrument])
def close_all_options(self):
for option in self.account.dict_holding.values():
if isinstance(option, BaseOption):
order = self.account.create_close_order(
option, cd_trade_price=self.cd_trade_price)
record = option.execute_order(order, slippage=self.slippage)
self.account.add_record(record, option)
def strategy(self):
if self.cd_strategy == 'short_straddle':
return self.short_straddle()
elif self.cd_strategy == 'short_put':
return self.short_put()
elif self.cd_strategy == 'short_call':
return self.short_call()
def short_straddle(self):
maturity1 = self.optionset.select_maturity_date(
nbr_maturity=self.nbr_maturity, min_holding=self.min_holding)
list_atm_call, list_atm_put = self.optionset.get_options_list_by_moneyness_mthd1(
moneyness_rank=self.moneyness_rank,
maturity=maturity1,
cd_price=c.CdPriceType.OPEN)
atm_call = self.optionset.select_higher_volume(list_atm_call)
atm_put = self.optionset.select_higher_volume(list_atm_put)
if atm_call is None or atm_put is None:
return
else:
return [atm_call, atm_put]
def short_put(self):
maturity1 = self.optionset.select_maturity_date(
nbr_maturity=self.nbr_maturity, min_holding=self.min_holding)
list_atm_call, list_atm_put = self.optionset.get_options_list_by_moneyness_mthd1(
moneyness_rank=self.moneyness_rank,
maturity=maturity1,
cd_price=c.CdPriceType.OPEN)
atm_put = self.optionset.select_higher_volume(list_atm_put)
if atm_put is None:
return
else:
return [atm_put]
def short_call(self):
maturity1 = self.optionset.select_maturity_date(
nbr_maturity=self.nbr_maturity, min_holding=self.min_holding)
list_atm_call, list_atm_put = self.optionset.get_options_list_by_moneyness_mthd1(
moneyness_rank=self.moneyness_rank,
maturity=maturity1,
cd_price=c.CdPriceType.OPEN)
atm_call = self.optionset.select_higher_volume(list_atm_call)
if atm_call is None:
return
else:
return [atm_call]
def excute(self, strategy):
if strategy is None:
return True
else:
pv = self.account.portfolio_total_value
for option in strategy:
unit = np.floor(
np.floor(pv / option.strike()) /
option.multiplier()) * self.m
order = self.account.create_trade_order(
option,
c.LongShort.SHORT,
unit,
cd_trade_price=self.cd_trade_price)
record = option.execute_order(order, slippage=self.slippage)
self.account.add_record(record, option)
return False
def back_test(self):
empty_position = True
index_npv = []
while self.optionset.eval_date <= self.end_date:
# print(optionset.eval_date)
# if self.account.cash <= 0: break
if self.optionset.eval_date >= self.end_date: # Final close out all.
self.close_out()
self.account.daily_accounting(self.optionset.eval_date)
index_npv.append(self.index.mktprice_close() / self.init_index)
break
# 平仓
if not empty_position and self.close_signal():
self.close_all_options()
empty_position = True
# 开仓
if empty_position:
empty_position = self.excute(self.strategy())
self.account.daily_accounting(self.optionset.eval_date)
index_npv.append(self.index.mktprice_close() / self.init_index)
# print(self.optionset.eval_date,self.account.account.loc[self.optionset.eval_date,c.Util.PORTFOLIO_NPV])
if not self.optionset.has_next(): break
self.optionset.next()
self.index.next()
self.account.account['index_npv'] = index_npv
# 标的指数开仓
unit_index = np.floor(m * account.cash / index.mktprice_close() /
index.multiplier())
option_shares = unit_index
init_mktvalue = unit_index * index.mktprice_close() * index.multiplier()
# order_index = account.create_trade_order(index, c.LongShort.LONG, unit_index, cd_trade_price=c.CdTradePrice.CLOSE)
# record_index = index.execute_order(order_index, slippage=slippage)
# account.add_record(record_index, index)
# 标的换成股票指数
unit_stock = np.floor(init_mktvalue / stock.mktprice_close() /
stock.multiplier())
order_underlying = account.create_trade_order(
stock, c.LongShort.LONG, unit_stock, cd_trade_price=c.CdTradePrice.CLOSE)
record_underlying = stock.execute_order(order_underlying, slippage=slippage)
account.add_record(record_underlying, stock)
init_stock = stock.mktprice_close()
empty_position = True
call = None
put = None
while optionset.has_next():
if maturity1 > end_date: # Final close out all.
close_out_orders = account.creat_close_out_order()
for order in close_out_orders:
execution_record = account.dict_holding[
order.id_instrument].execute_order(
order,
slippage=0,
execute_type=c.ExecuteType.EXECUTE_ALL_UNITS)
account.add_record(execution_record,
account.dict_holding[order.id_instrument])
class VolTrading(object):
def __init__(self, start_date, end_date, df_metrics, df_vol,
df_future_c1_daily, df_futures_all_daily):
self.min_holding = 20
self.slippage = 0
self.nbr_maturity = 0
self.moneyness_rank = 0
self.m_notional = 1
self.rf = 0.03
self.n_premium_std = 90 #用于计算权利金溢价1倍标准差的数据期限
self.n_hv = 20 # 用与期权期限相匹配的历史波动率期限
self.n_close_by_maturity = 5
self.min_premium = 2.0 / 100.0 # 对冲成本对应的开平仓最低隐含波动率溢价
self.n_llt = 5
self.cd_option_price = c.CdTradePrice.CLOSE
self.cd_future_price = c.CdTradePrice.CLOSE
self.cd_price = c.CdPriceType.CLOSE
self.start_date = start_date
self.end_date = end_date
self.df_metrics = df_metrics
self.df_vol = df_vol
self.df_f_c1 = df_future_c1_daily
self.df_f_all = df_futures_all_daily
def init(self):
df_future_histvol = self.df_f_c1.copy()
df_future_histvol['amt_hv'] = histvol.hist_vol(
df_future_histvol[c.Util.AMT_CLOSE], n=self.n_hv)
self.dt_start = max(self.df_f_c1[c.Util.DT_DATE].values[0],
self.df_metrics[c.Util.DT_DATE].values[0])
self.end_date = min(self.df_f_c1[c.Util.DT_DATE].values[-1],
self.df_metrics[c.Util.DT_DATE].values[-1])
self.df_metrics = self.df_metrics[
self.df_metrics[c.Util.DT_DATE] >= self.dt_start].reset_index(
drop=True)
self.df_f_c1 = self.df_f_c1[
self.df_f_c1[c.Util.DT_DATE] >= self.dt_start].reset_index(
drop=True)
self.df_f_all = self.df_f_all[
self.df_f_all[c.Util.DT_DATE] >= self.dt_start].reset_index(
drop=True)
self.df_vol = pd.merge(self.df_vol,
df_future_histvol[[c.Util.DT_DATE, 'amt_hv']],
on=c.Util.DT_DATE).set_index(c.Util.DT_DATE)
self.optionset = BaseOptionSet(self.df_metrics)
self.optionset.init()
self.hedging = SytheticOption(self.df_f_c1,
rf=self.rf,
df_futures_all_daily=self.df_f_all)
self.hedging.init()
self.hedging.amt_option = 1 / 1000 # 50ETF与IH点数之比
self.account = BaseAccount(init_fund=c.Util.BILLION, rf=self.rf)
self.prepare_timing()
def prepare_timing(self):
self.timing_hviv()
self.timing_llt()
def timing_hviv(self):
self.df_vol['amt_premium'] = self.df_vol[
c.Util.PCT_IMPLIED_VOL] - self.df_vol['amt_hv']
self.df_vol['amt_1std'] = c.Statistics.standard_deviation(
self.df_vol['amt_premium'], n=self.n_premium_std)
self.df_vol['amt_2std'] = 2 * c.Statistics.standard_deviation(
self.df_vol['amt_premium'], n=self.n_premium_std)
self.df_vol['percentile_95'] = c.Statistics.percentile(
self.df_vol[c.Util.PCT_IMPLIED_VOL], n=252, percent=0.95)
def timing_llt(self):
self.df_vol['LLT_' + str(self.n_llt)] = LLT(
self.df_vol[c.Util.PCT_IMPLIED_VOL], self.n_llt)
self.df_vol['LLT_signal_' +
str(self.n_llt)] = self.df_vol['LLT_' +
str(self.n_llt)].diff()
def open_signal(self):
pass
def close_signal(self):
pass
def open_signal_llt(self):
dt_date = self.optionset.eval_date
if dt_date not in self.df_vol.index:
return False
if self.df_vol.loc[dt_date, 'LLT_signal_5'] < 0: # 隐含波动率处于下行区间
return True
else:
return False
def close_signal_llt(self):
dt_date = self.optionset.eval_date
if dt_date not in self.df_vol.index:
return False
if self.df_vol.loc[dt_date, 'LLT_signal_5'] > 0: # 隐含波动率处于上行区间
return True
else:
return False
def open_signal_ivhv(self):
dt_date = self.optionset.eval_date
if dt_date not in self.df_vol.index:
return False
amt_premium = self.df_vol.loc[dt_date, 'amt_premium']
amt_1std = self.df_vol.loc[dt_date, 'amt_1std']
if amt_premium > amt_1std and amt_premium > self.min_premium: # 隐含波动率相比历史波动率具有一定溢价
return True
else:
return False
def close_signal_ivhv(self):
dt_date = self.optionset.eval_date
amt_premium = self.df_vol.loc[dt_date, 'amt_premium']
if amt_premium <= self.min_premium:
return True
else:
return False
def close_signal_maturity(self):
dt_maturity = None
for option in self.account.dict_holding.values():
if isinstance(option, BaseOption) and option is not None:
dt_maturity = option.maturitydt()
break
if (dt_maturity -
self.optionset.eval_date).days <= self.n_close_by_maturity:
return True
else:
return False
def strategy(self):
return self.short_straddle()
def short_straddle(self):
maturity = self.optionset.select_maturity_date(
nbr_maturity=self.nbr_maturity, min_holding=self.min_holding)
list_atm_call, list_atm_put = self.optionset.get_options_list_by_moneyness_mthd1(
moneyness_rank=self.moneyness_rank,
maturity=maturity,
cd_price=self.cd_price)
atm_call = self.optionset.select_higher_volume(list_atm_call)
atm_put = self.optionset.select_higher_volume(list_atm_put)
if atm_call is None or atm_put is None:
return
else:
return [atm_call, atm_put]
def excute(self, strategy):
if strategy is None:
return False
else:
pv = self.account.portfolio_total_value
self.option_holding = {}
for option in strategy:
unit = np.floor(
np.floor(pv / option.strike()) /
option.multiplier()) * self.m_notional
order = self.account.create_trade_order(
option,
c.LongShort.SHORT,
unit,
cd_trade_price=self.cd_option_price)
record = option.execute_order(order,
slippage_rate=self.slippage)
self.account.add_record(record, option)
self.option_holding.update({option: unit})
return True
def close_out(self):
close_out_orders = self.account.creat_close_out_order(
cd_trade_price=c.CdTradePrice.CLOSE)
for order in close_out_orders:
execution_record = self.account.dict_holding[order.id_instrument] \
.execute_order(order, slippage_rate=self.slippage, execute_type=c.ExecuteType.EXECUTE_ALL_UNITS)
self.account.add_record(
execution_record,
self.account.dict_holding[order.id_instrument])
def close_out_1(self):
for option in self.account.dict_holding.values():
if isinstance(option, BaseOption):
order = self.account.create_close_order(
option, cd_trade_price=self.cd_option_price)
else:
order = self.account.create_close_order(
option, cd_trade_price=self.cd_future_price)
record = option.execute_order(order, slippage_rate=self.slippage)
self.account.add_record(record, option)
# TODO: Use Delta Bound Model
def delta_hedge(self):
option1 = list(self.option_holding.keys())[0]
iv_htbr = self.optionset.get_iv_by_otm_iv_curve(
dt_maturity=option1.maturitydt(),
strike=option1.applicable_strike())
options_delta = 0
for option in self.option_holding.keys():
unit = self.option_holding[option]
options_delta += unit * option.get_delta(
iv_htbr) * option.multiplier()
hedge_unit = self.hedging.get_hedge_rebalancing_unit(
options_delta, c.BuyWrite.WRITE)
self.hedging.synthetic_unit += -hedge_unit
if hedge_unit > 0:
long_short = c.LongShort.LONG
else:
long_short = c.LongShort.SHORT
order_u = self.account.create_trade_order(
self.hedging,
long_short,
hedge_unit,
cd_trade_price=self.cd_future_price)
record_u = self.hedging.execute_order(order_u,
slippage_rate=self.slippage)
self.account.add_record(record_u, self.hedging)
# print('')
def back_test(self):
empty_position = True
while self.optionset.eval_date <= self.end_date:
# if self.optionset.eval_date == datetime.date(2017, 1, 19):
# print('')
if self.optionset.eval_date >= self.end_date: # Final close out all.
self.close_out()
self.account.daily_accounting(self.optionset.eval_date)
print(self.optionset.eval_date, ' close out ')
print(
self.optionset.eval_date, self.hedging.eval_date,
self.account.account.loc[self.optionset.eval_date,
c.Util.PORTFOLIO_NPV],
int(self.account.cash))
break
# 标的移仓换月
if self.hedging.close_old_contract_month(
self.account, self.slippage,
cd_price=self.cd_future_price):
self.hedging.synthetic_unit = 0
# 平仓
if not empty_position:
if self.close_signal():
self.close_out_1()
self.hedging.synthetic_unit = 0
empty_position = True
# 开仓
if empty_position and self.open_signal():
s = self.strategy()
empty_position = not self.excute(s)
# Delta hedge
if not empty_position:
self.delta_hedge()
self.account.daily_accounting(self.optionset.eval_date)
if not self.optionset.has_next():
break
self.optionset.next()
self.hedging.next()
return self.account