dict_annualized_volatility = {'m': moneyness}
dict_max_drawdown = {'m': moneyness}
dict_sharpe_ratio = {'m': moneyness}
dict_pct_option_amt = {'m': moneyness}
# for target_delta in [-0.1,-0.2,-0.3,-0.4]:
for target_delta in [None]:
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)
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
index = BaseInstrument(df_index)
index.init()
stock = BaseInstrument(df_stocks)
stock.init()
account = BaseAccount(init_fund=c.Util.BILLION, leverage=1.0, rf=0.0)
maturity = optionset.select_maturity_date(nbr_maturity=nbr_maturity, min_holding=min_holding)
# 标的指数开仓
# unit_index = np.floor(m*account.cash/index.mktprice_close()/index.multiplier())
# 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)
# 标的换成股票指数
init_mktvalue = m*account.cash
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
put = None
while optionset.has_next():
if maturity > 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)
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
c.Util.DT_DATE, c.Util.ID_INSTRUMENT, c.Util.AMT_CLOSE, 'close_alpha'
]].rename(columns={c.Util.AMT_CLOSE: 'etf_close'})
df_underlying_with_alpha = df_underlying_with_alpha.rename(
columns={'close_alpha': c.Util.AMT_CLOSE})
# df_underlying_with_alpha.to_csv('../accounts_data/df_underlying_with_alpha='+str(alpha)+'.csv')
""" Init Portfolio and Account """
init_fund = 10000000
optionset = BaseOptionSet(df_metrics_1)
optionset.init()
underlying = BaseInstrument(df_underlying_with_alpha)
underlying.init()
account = BaseAccount(init_fund, leverage=1.0, rf=0.03)
""" 初始开仓 """
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)
equal_50etf_unit = unit_underlying * underlying.mktprice_close(
) / optionset.eligible_options[0].underlying_close()
atm_put, premium = buy_put(moneyness, maturity1)
# SH300指数
total_premium = premium
while optionset.has_next():
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
""" Collar """
optionset = BaseOptionSet(df_metrics)
optionset.init()
index = BaseInstrument(df_index)
index.init()
stock = BaseInstrument(df_stocks)
stock.init()
account = BaseAccount(init_fund=c.Util.BILLION, leverage=1.0, rf=0.03)
maturity1 = optionset.select_maturity_date(nbr_maturity=0,
min_holding=min_holding)
maturity2 = optionset.select_maturity_date(nbr_maturity=0,
min_holding=min_holding)
# 标的指数开仓
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