基于 VIX 指数的择时策略

来源:https://uqer.io/community/share/55b6152ff9f06c91fa18c5c9

波动率VIX指数是跟踪市场波动性的指数,一般通过标的期权的隐含波动率计算得来,以芝加哥期权交易所的VIX指数为例,如标的期权的隐含波动率越高,则VIX指数相应越高,一般而言,该指数反映出投资者愿意付出多少成本去对冲投资风险。业内认为,当VIX越高时,表示市场参与者预期后市波动程度会更加激烈,同时也反映其不安的心理状态;相反,VIX越低时,则反映市场参与者预期后市波动程度会趋于缓和的心态。因此,VIX又被称为投资人恐慌指标(The Investor Fear Gauge)。

中国波指是由上证所发布,用于衡量上证50ETF未来30日的预期波动。该指数是根据方差互换的原理,结合50ETF期权的实际运作特点,并通过对上证所交易的50ETF期权价格的计算编制而得。网址为: http://www.sse.com.cn/assortment/derivatives/options/volatility/

本文中,基于优矿平台,自己尝试计算了日间的中国波指,并将其用在了华夏上证50的择时买卖上,以验证VIX指数对未来的预测性

由于上证所未发布其iVIX计算方法,所以此处的计算基于CBOE发布的方法,具体参见: http://www.cboe.com/micro/vix/part2.aspx

策略思路

  • 当VIX指数快速上升时,表示市场恐慌情绪蔓延,产生卖出信号
  • 当VIX指数快速下降时,恐慌情绪有所舒缓,产生买入信号
  • 卖出买入信号均用来买卖华夏上证50ETF基金 注:国内唯一一只期权上证50ETF期权,跟踪标的为华夏上证50ETF(510050)基金

1. 计算历史VIX指数

  1. from matplotlib import pylab
  2. import numpy as np
  3. import pandas as pd
  4. import DataAPI
  5. import seaborn as sns
  6. sns.set_style('white')
  1. from CAL.PyCAL import *
  2. from pandas import Series, DataFrame, concat
  3. import pandas as pd
  4. import numpy as np
  5. import seaborn as sns
  6. sns.set_style('white')
  7. from matplotlib import pylab
  8. import time
  9. import math
  10. def getHistDayOptions(var, date):
  11. # 使用DataAPI.OptGet,拿到已退市和上市的所有期权的基本信息;
  12. # 同时使用DataAPI.MktOptdGet,拿到历史上某一天的期权成交信息;
  13. # 返回历史上指定日期交易的所有期权信息,包括:
  14. # optID varSecID contractType strikePrice expDate tradeDate closePrice
  15. # 以optID为index。
  16. vixDateStr = date.toISO().replace('-', '')
  17. optionsMkt = DataAPI.MktOptdGet(tradeDate = vixDateStr, field = [u"optID", "tradeDate", "closePrice"], pandas = "1")
  18. optionsMkt = optionsMkt.set_index(u"optID")
  19. optionsMkt.closePrice.name = u"price"
  20. optionsID = map(str, optionsMkt.index.values.tolist())
  21. fieldNeeded = ["optID", u"varSecID", u'contractType', u'strikePrice', u'expDate']
  22. optionsInfo = DataAPI.OptGet(optID=optionsID, contractStatus = [u"DE", u"L"], field=fieldNeeded, pandas="1")
  23. optionsInfo = optionsInfo.set_index(u"optID")
  24. options = concat([optionsInfo, optionsMkt], axis=1, join='inner').sort_index()
  25. return options[options.varSecID==var]
  26. def getNearNextOptExpDate(options, vixDate):
  27. # 找到options中的当月和次月期权到期日;
  28. # 用这两个期权隐含的未来波动率来插值计算未来30隐含波动率,是为市场恐慌指数VIX;
  29. # 如果options中的最近到期期权离到期日仅剩1天以内,则抛弃这一期权,改
  30. # 选择次月期权和次月期权之后第一个到期的期权来计算。
  31. # 返回的near和next就是用来计算VIX的两个期权的到期日
  32. optionsExpDate = Series(options.expDate.values.ravel()).unique().tolist()
  33. near = min(optionsExpDate)
  34. optionsExpDate.remove(near)
  35. if Date.parseISO(near) - vixDate < 1:
  36. near = min(optionsExpDate)
  37. optionsExpDate.remove(near)
  38. next = min(optionsExpDate)
  39. return near, next
  40. def getStrikeMinCallMinusPutClosePrice(options):
  41. # options 中包括计算某日VIX的call和put两种期权,
  42. # 对每个行权价,计算相应的call和put的价格差的绝对值,
  43. # 返回这一价格差的绝对值最小的那个行权价,
  44. # 并返回该行权价对应的call和put期权价格的差
  45. call = options[options.contractType==u"CO"].set_index(u"strikePrice").sort_index()
  46. put = options[options.contractType==u"PO"].set_index(u"strikePrice").sort_index()
  47. callMinusPut = call.closePrice - put.closePrice
  48. strike = abs(callMinusPut).idxmin()
  49. priceDiff = callMinusPut[strike]
  50. return strike, priceDiff
  51. def calSigmaSquare(options, FF, R, T):
  52. # 计算某个到期日期权对于VIX的贡献sigma;
  53. # 输入为期权数据options,FF为forward index price,
  54. # R为无风险利率, T为期权剩余到期时间
  55. callAll = options[options.contractType==u"CO"].set_index(u"strikePrice").sort_index()
  56. putAll = options[options.contractType==u"PO"].set_index(u"strikePrice").sort_index()
  57. callAll['deltaK'] = 0.05
  58. putAll['deltaK'] = 0.05
  59. # Interval between strike prices
  60. index = callAll.index
  61. if len(index) < 3:
  62. callAll['deltaK'] = index[-1] - index[0]
  63. else:
  64. for i in range(1,len(index)-1):
  65. callAll['deltaK'].ix[index[i]] = (index[i+1]-index[i-1])/2.0
  66. callAll['deltaK'].ix[index[0]] = index[1]-index[0]
  67. callAll['deltaK'].ix[index[-1]] = index[-1] - index[-2]
  68. index = putAll.index
  69. if len(index) < 3:
  70. putAll['deltaK'] = index[-1] - index[0]
  71. else:
  72. for i in range(1,len(index)-1):
  73. putAll['deltaK'].ix[index[i]] = (index[i+1]-index[i-1])/2.0
  74. putAll['deltaK'].ix[index[0]] = index[1]-index[0]
  75. putAll['deltaK'].ix[index[-1]] = index[-1] - index[-2]
  76. call = callAll[callAll.index > FF]
  77. put = putAll[putAll.index < FF]
  78. FF_idx = FF
  79. if not put.empty:
  80. FF_idx = put.index[-1]
  81. put['closePrice'].iloc[-1] = (putAll.ix[FF_idx].closePrice + callAll.ix[FF_idx].closePrice)/2.0
  82. callComponent = call.closePrice*call.deltaK/call.index/call.index
  83. putComponent = put.closePrice*put.deltaK/put.index/put.index
  84. sigma = (sum(callComponent)+sum(putComponent))*np.exp(T*R)*2/T
  85. sigma = sigma - (FF/FF_idx - 1)**2/T
  86. return sigma
  87. def calDayVIX(optionVarSecID, vixDate):
  88. # 利用CBOE的计算方法,计算历史某一日的未来30日期权波动率指数VIX
  89. # The risk-free interest rates
  90. R_near = 0.06
  91. R_next = 0.06
  92. # 拿取所需期权信息
  93. options = getHistDayOptions(optionVarSecID, vixDate)
  94. termNearNext = getNearNextOptExpDate(options, vixDate)
  95. optionsNearTerm = options[options.expDate == termNearNext[0]]
  96. optionsNextTerm = options[options.expDate == termNearNext[1]]
  97. # time to expiration
  98. T_near = (Date.parseISO(termNearNext[0]) - vixDate)/365.0
  99. T_next = (Date.parseISO(termNearNext[1]) - vixDate)/365.0
  100. # the forward index prices
  101. nearPriceDiff = getStrikeMinCallMinusPutClosePrice(optionsNearTerm)
  102. nextPriceDiff = getStrikeMinCallMinusPutClosePrice(optionsNextTerm)
  103. near_F = nearPriceDiff[0] + np.exp(T_near*R_near)*nearPriceDiff[1]
  104. next_F = nextPriceDiff[0] + np.exp(T_next*R_next)*nextPriceDiff[1]
  105. # 计算不同到期日期权对于VIX的贡献
  106. near_sigma = calSigmaSquare(optionsNearTerm, near_F, R_near, T_near)
  107. next_sigma = calSigmaSquare(optionsNextTerm, next_F, R_next, T_next)
  108. # 利用两个不同到期日的期权对VIX的贡献sig1和sig2,
  109. # 已经相应的期权剩余到期时间T1和T2;
  110. # 差值得到并返回VIX指数(%)
  111. w = (T_next - 30.0/365.0)/(T_next - T_near)
  112. vix = T_near*w*near_sigma + T_next*(1 - w)*next_sigma
  113. return 100*np.sqrt(vix*365.0/30.0)
  114. def getHistVIX(beginDate, endDate):
  115. # 计算历史一段时间内的VIX指数并返回
  116. optionVarSecID = u"510050.XSHG"
  117. cal = Calendar('China.SSE')
  118. dates = cal.bizDatesList(beginDate, endDate)
  119. dates = map(Date.toDateTime, dates)
  120. histVIX = pd.DataFrame(0.0, index=dates, columns=['VIX'])
  121. histVIX.index.name = 'date'
  122. for date in histVIX.index:
  123. histVIX['VIX'][date] = calDayVIX(optionVarSecID, Date.fromDateTime(date))
  124. return histVIX
  125. def getDayVIX(date):
  126. optionVarSecID = u"510050.XSHG"
  127. return calDayVIX(optionVarSecID, date)

2. VIX指数与华夏上证50ETF基金的走势对比

  1. secID = '510050.XSHG'
  2. begin = Date(2015, 2, 9)
  3. end = Date(2015, 7, 23)
  4. # 历史VIX
  5. histVIX = getHistVIX(begin, end)
  6. # 华夏上证50ETF
  7. etf = DataAPI.MktFunddGet(secID, beginDate=begin.toISO().replace('-', ''), endDate=end.toISO().replace('-', ''), field=['tradeDate', 'closePrice'])
  8. etf['tradeDate'] = pd.to_datetime(etf['tradeDate'])
  9. etf = etf.set_index('tradeDate')
  1. font.set_size(12)
  2. pylab.figure(figsize = (16,8))
  3. ax1 = histVIX.plot(x=histVIX.index, y='VIX', style='r')
  4. ax1.set_xlabel(u'日期', fontproperties=font)
  5. ax1.set_ylabel(u'VIX(%)', fontproperties=font)
  6. ax2 = ax1.twinx()
  7. ax2.plot(etf.index,etf.closePrice)
  8. ax2.set_ylabel(u'ETF Price', fontproperties=font)
  9. <matplotlib.text.Text at 0x5a66390>

基于 VIX 指数的择时策略 - 图1

关于VIX,比较成熟的美国市场中,标普500指数和相应的VIX之间呈负相关性。具体可以参照CBOE的数据:http://www.cboe.com/micro/vix/part3.aspx

这可以理解为:

  • 当VIX越高时,表示市场参与者预期后市波动程度会更加激烈,所以谨慎持仓,甚至逐渐减仓;
  • 相反,VIX越低时,市场参与者预期后市波动程度会趋于缓和,开始放心投资股市。 上图中的中国市场VIX指数与华夏上证50ETF走势对比中,我们不难发现以下几点:

  • 上证50ETF期权于2月9日上市,之后一个月VIX稳定在低位运行,同时市场也表现出稳定的态势

  • 3月下旬到5月初一段时间,VIX指数显著上升,表示市场认为后期震荡会加剧,但这种恐慌淹没在牛市大潮中
  • 5月到6月VIX高位运行,但似乎没有引起市场的足够重视
  • 6月中的股市大跌开始后,VIX指数快速上升到接近60
  • 7月时候,市场认可国家救市决心,VIX开始从高位迅速下降,股指也日趋稳定 可以看出,VIX指数在和股指的并驾齐驱中总是慢人一步,没法充分表现出股指在六月极高位时候市场的不安;实际上,国内期权市场建立不足半年,期权流动性并不够大,导致基于期权市场的VIX指数对于中国股市的预测并不如成熟市场一样流畅

3. 基于VIX指数的择时策略示例

  1. start = datetime(2015, 2, 9) # 回测起始时间
  2. end = datetime(2015, 7, 26) # 回测结束时间
  3. benchmark = '510050.XSHG' # 策略参考标准
  4. universe = ['510050.XSHG'] # 股票池
  5. capital_base = 100000 # 起始资金
  6. commission = Commission(0.0,0.0)
  7. window_short = 1
  8. window_long = 5
  9. longest_history = 1
  10. SD = 0.08
  11. histVIX['short_window'] = pd.rolling_mean(histVIX['VIX'], window=window_short)
  12. histVIX['long_window'] = pd.rolling_mean(histVIX['VIX'], window=window_long)
  13. def initialize(account): # 初始化虚拟账户状态
  14. account.fund = universe[0]
  15. def handle_data(account): # 每个交易日的买入卖出指令
  16. hist = account.get_history(longest_history)
  17. fund = account.fund
  18. # 获取回测当日的前一天日期
  19. dt = Date.fromDateTime(account.current_date)
  20. cal = Calendar('China.IB')
  21. lastTDay = cal.advanceDate(dt,'-1B',BizDayConvention.Preceding) #计算出前一个交易日期
  22. last_day_str = lastTDay.strftime("%Y-%m-%d")
  23. # 计算买入卖出信号
  24. try:
  25. short_mean = histVIX['short_window'].loc[last_day_str] # 计算短均线值
  26. long_mean = histVIX['long_window'].loc[last_day_str] # 计算长均线值
  27. long_flag = True if (short_mean - long_mean) < -SD * long_mean else False
  28. short_flag = True if (short_mean - long_mean) > SD * long_mean else False
  29. except:
  30. long_flag = False
  31. short_flag = False
  32. if long_flag:
  33. if account.position.secpos.get(fund, 0) == 0:
  34. # 空仓时全仓买入,买入股数为100的整数倍
  35. approximationAmount = int(account.cash / hist[fund]['closePrice'][-1]/100.0) * 100
  36. order(fund, approximationAmount)
  37. elif short_flag:
  38. # 卖出时,全仓清空
  39. if account.position.secpos.get(fund, 0) >= 0:
  40. order_to(fund, 0)

基于 VIX 指数的择时策略 - 图2

可以看出:

  • 基于VIX指数高位时空仓、低位时进场的策略,可以比较有效地避开股指大跌的风险
  • 但由于国内期权市场流动性不足,VIX指数并不能有效反应市场的情绪,导致我们也错过了很多牛市的蛋糕