跳转到内容

13.6 Python 量化实践:六个小项目

难度★★★

你多半用过券商的期权计算器:输入股价、行权价、到期日和 IV,它给出期权价格和希腊字母。它用的是哪个模型,利率和股息怎样处理,页面上都看不到,所以它算出的数对不对,你没有办法检查。本课程从第2章起的报价、例子和配图,都是用同一个 Black-Scholes 模型(2.8)算出来的。这一节把这个模型和前面各章的几个算法写成 Python 代码,并回答一个问题:怎样确认自己算的数是对的?

代码跑出了一个数,只说明程序没有报错,不说明公式写对了。要确认它,就用一定成立的关系去核对:平价关系(2.7)在任何 IV 下都成立;Delta 一定等于价格随股价的变化率;同一个随机种子的模拟,重跑一次一定得到同样的数。把这些核对写成每次修改代码后都自动运行的检查(「准备」一节给出它的定义),错误就会被自动发现。另一半是写明假设:模型里没有的东西,例如偏斜、跳空和让价,算出的数里也不会有。

这一节有六个小项目,每个写成一个文件。13.2、13.3、13.7、13.8 的项目都要用这里的代码,所以第13章推荐先学这一节。你需要会基本的 Python(变量、函数、循环、列表);如果从没写过代码,先另花 10–20 小时学入门语法。

文件 做什么 怎样检查
bs.py 定价与 Delta、Gamma、Vega 平价测试、有限差分测试
iv.py 由期权价格反求 IV 先查无套利区间,代回得原价
mc_pnl.py 到期盈亏的分布与尾部风险 固定种子,不超过最大亏损
event_vol.py 事件波动率与基准 IV 两种方法互相核对
scalp_sim.py Gamma scalping 的结果分布 与 Vega × (实现波动率 − IV) 比较
backtest/fills.py 三种成交价假设 三个价格的大小顺序

读法:iv.py 和 scalp_sim.py 直接调用 bs.py,mc_pnl.py 里的权利金也是用同一个模型算出的。bs.py 错了,后面的数字全都跟着错,所以先做项目 1,测试全部通过以后再往下做。每个项目都先列出输入、输出、假设和检查办法,再给代码、运行输出和读法。

  • 环境:Python 3.10 以上,另需 numpy、scipy、matplotlib、pytest 四个库,安装命令是 pip install numpy scipy matplotlib pytest。
  • 新建一个文件夹(例如 options/),每个项目写成一个文件;测试放在以 test_ 开头的同名文件里。
  • 单元测试(unit test)是一小段自动运行的检查代码,它断言「在已知输入下,结果必须满足某个条件」。每次修改代码后重新运行一遍,出现错误就会立刻报告。
  • 最容易出错的是单位:
    • IV 写成小数:15% 写作 0.15,而不是 15。
    • 时间换算成年:30 天写作 30/365。
    • 利率也写成小数:4% 写作 0.04。
    • 算出的价格是每股的价格,乘以 100 才是每张的价格。
  • 每个文件只完成一件事;函数的输入、输出和单位都写在注释里。
  • 下面的代码都实际运行过,输出附在代码之后,数字与课程的示例价格一致。

项目 1:bs.py——定价与希腊字母

Section titled “项目 1:bs.py——定价与希腊字母”
  • 输入:股价 S、行权价 K(美元);剩余时间 T(年,30 天写 30/365);利率 r、股息率 q、IV sigma(都写成小数);cp 是 "c"(call)或 "p"(put)。
  • 输出:每股的价格(美元);Delta 和 Gamma 按股价每变动 $1 计,Vega 按 IV 每变动 1 个点计。
  • 假设:欧式期权;股价服从对数正态分布,IV、利率和股息率在期内不变(2.8)。
  • 检查:test_bs.py 的平价测试和有限差分测试;另外把输出与课程的已知数字核对一次。

bs.py 用 numpy 编写,而 numpy 的函数会对数组逐个元素计算,所以同一个函数既能算一个数,也能一次算一整组数。

# bs.py:Black-Scholes 定价与希腊字母(欧式,连续股息率 q)
import numpy as np
from scipy.stats import norm
def d1_d2(S, K, T, r, q, sigma):
d1 = (np.log(S / K) + (r - q + 0.5 * sigma**2) * T) / (sigma * np.sqrt(T))
return d1, d1 - sigma * np.sqrt(T)
def bs_price(S, K, T, r, q, sigma, cp):
d1, d2 = d1_d2(S, K, T, r, q, sigma)
if cp == "c":
return S * np.exp(-q * T) * norm.cdf(d1) - K * np.exp(-r * T) * norm.cdf(d2)
return K * np.exp(-r * T) * norm.cdf(-d2) - S * np.exp(-q * T) * norm.cdf(-d1)
def bs_delta(S, K, T, r, q, sigma, cp):
d1, _ = d1_d2(S, K, T, r, q, sigma)
return np.exp(-q * T) * (norm.cdf(d1) if cp == "c" else norm.cdf(d1) - 1)
def bs_gamma(S, K, T, r, q, sigma):
d1, _ = d1_d2(S, K, T, r, q, sigma)
return np.exp(-q * T) * norm.pdf(d1) / (S * sigma * np.sqrt(T))
def bs_vega(S, K, T, r, q, sigma): # 每 1 个 IV 点
d1, _ = d1_d2(S, K, T, r, q, sigma)
return S * np.exp(-q * T) * norm.pdf(d1) * np.sqrt(T) / 100
if __name__ == "__main__":
spy = (770, 770, 30 / 365, 0.04, 0.012, 0.15) # SPY 770,30 天,IV 15%
print(f"{bs_price(*spy, 'c'):.2f} {bs_price(*spy, 'p'):.2f}")
print(f"{bs_delta(*spy, 'c'):.3f} {bs_gamma(*spy):.4f} {bs_vega(*spy):.3f}")

运行 python bs.py 的输出:

14.08 12.32
0.529 0.0120 0.877

结果与第3章的 SPY 770C 一致(示例价格,非实时):模型价 $14.08(报价取到 $0.05 的格点是 $14.10),Δ 0.53、Γ 0.012、Vega 0.88。

两个必备的测试写在 test_bs.py 里:

# test_bs.py:在终端运行 pytest
from math import exp
from bs import bs_price, bs_delta, bs_gamma, bs_vega
CASES = [(770, 770, 30/365, 0.04, 0.012, 0.15), # SPY 平值
(225, 250, 30/365, 0.04, 0.0, 0.40), # NVDA 虚值
(340, 310, 90/365, 0.04, 0.003, 0.25)] # AAPL 实值
def test_put_call_parity():
for S, K, T, r, q, s in CASES:
lhs = bs_price(S, K, T, r, q, s, "c") - bs_price(S, K, T, r, q, s, "p")
rhs = S * exp(-q * T) - K * exp(-r * T)
assert abs(lhs - rhs) < 1e-8
def test_greeks_match_finite_difference():
h = 0.01
for S, K, T, r, q, s in CASES:
for cp in ("c", "p"): # call 和 put 各查一遍
up, mid, dn = (bs_price(x, K, T, r, q, s, cp) for x in (S + h, S, S - h))
assert abs((up - dn) / (2 * h) - bs_delta(S, K, T, r, q, s, cp)) < 1e-5
assert abs((up - 2 * mid + dn) / h**2 - bs_gamma(S, K, T, r, q, s)) < 1e-4
v_up = bs_price(S, K, T, r, q, s + 1e-4, cp)
v_dn = bs_price(S, K, T, r, q, s - 1e-4, cp)
assert abs((v_up - v_dn) / 2e-4 / 100 - bs_vega(S, K, T, r, q, s)) < 1e-5

pytest 会运行文件里每一个以 test_ 开头的函数;assert 条件 的意思是「这个条件必须成立」,不成立,这个测试就算失败,并指出是哪一行。第一个测试检查平价关系:C − P 必须等于 S·e^(−qT) − K·e^(−rT),误差小于 1e-8。平价关系与 IV 无关,只要价格公式里有符号错误,或者漏掉了股息项 e^(−qT)、贴现项 e^(−rT),两边就不相等,所以这个测试能发现这类错误。

第二个测试用有限差分(finite difference)检查希腊字母。Delta 是期权价格对股价的导数,所以把股价改变一个很小的量 h、重算价格,「价格变化 ÷ 股价的变化量」就应该等于公式给出的 Delta。代码里取股价上下各挪 h = $0.01,(up − dn) ÷ 2h 是 Delta 的近似值;(up − 2 × mid + dn) ÷ h² 是 Gamma 的近似值;把 IV 上下各挪 0.0001,再除以 100 换成每个 IV 点,是 Vega 的近似值。这三项对 call 和 put 各查一遍(cp 取 "c"、"p"),因为 put 的 Delta 是另一个公式,只查 call,put 的 Delta 写错了也发现不了。

运行 pytest,两个测试都通过。实测的平价误差不超过 1e-13,希腊字母的误差在 1e-8 量级或更小,都远低于容差。没有测试的代码只是看起来对,所以定价代码要通过两个测试:平价误差小于 1e-8;call 和 put 的 Delta、Gamma、Vega 都与有限差分一致。

为什么两个测试都要有?因为平价测试有一个盲区。把两个价格公式相减:

C−P=Se−qT[N(d1)+N(−d1)]−Ke−rT[N(d2)+N(−d2)]=Se−qT−Ke−rT\begin{aligned} C - P &= S e^{-qT}\left[N(d_1) + N(-d_1)\right] - K e^{-rT}\left[N(d_2) + N(-d_2)\right] \\ &= S e^{-qT} - K e^{-rT} \end{aligned}

第二行用到了正态分布的对称性:对任何 x,N(x) + N(−x) = 1。所以不管 d1、d2 算成多少,平价关系都成立。d1 里写错一个符号,call 和 put 的价格都错了,平价测试照样通过。这类错误要靠有限差分测试发现。Delta 公式虽然也用写错的 d1,但「Delta = e^(−qT)N(d1)」成立的前提是 d1 写对:只有正确的 d1,价格式里 N(d1)、N(d2) 对股价求导产生的其余各项才恰好抵消。d1 写错,这些项不再抵消,错价格对股价的变化率就不等于用错 d1 算出的 Delta,两者对不上,测试失败。下表是把 bs.py 故意改坏五次、各运行一遍两个测试的结果:

改坏的地方 平价测试 差分测试
call 里 K 前的减号写成加号 失败 失败
call 漏掉贴现项 e^(−rT) 失败 失败
d1 里的 +0.5σ² 写成 −0.5σ² 通过 失败
Delta 漏掉股息项 e^(−qT) 通过 q > 0 的两组失败
put 的 Delta 里 N(d1) − 1 写成 N(d1) + 1 通过 失败

读法:前两行是价格公式本身的结构错误,两个测试都发现了;后三行平价测试发现不了。第四行说明 CASES 为什么要有 q > 0 的用例:NVDA 一组的 q = 0,e^(−qT) = 1,漏掉它不改变结果,测试照样通过。最后一行说明差分测试为什么要对 put 也跑一遍:只查 call 时,这个错误两个测试都发现不了,而项目 5 的 scalp_sim.py 用的正是 put 的 Delta。平价测试发现价格公式里的符号、股息项和贴现项错误,发现不了 d1、d2 里的错误,这类错误和希腊字母公式的错误要靠对 call 和 put 都做的有限差分测试。

两个测试都发现不了单位错误:把 IV 写成 15,价格照样满足平价关系,导数也照样一致。所以 python bs.py 的输出要与课程的已知数字(14.08 / 12.32)核对一次。训练题 6 要求再补充三个测试,并说明每个测试防范的是哪一类错误。

随堂练习:把 bs.py 故意改坏两次,每次先预测,再运行核对。用这组新的输入:S = 180、K = 175、60 天、r = 4%、q = 2%、IV 30%。

(a) 把 bs_price 里 put 一行的 np.exp(-q * T) 删掉。pytest 的两个测试,哪一个会失败?对上面这组输入,平价两边相差约多少?提示:先用没改坏的 bs_delta 算出 put 的 Delta。

(b) 改回来,再把 bs_vega 末尾的 / 100 删掉。哪一个测试会失败?失败的那一行,有限差分的值与 bs_vega 的值相差约多少?

参考解答

(a) 两个测试都失败。先看平价测试。改坏以后,put 的公式少乘了 e^(−qT),减去的那一项变大,put 比正确的价格低 S·N(−d1)·(1 − e^(−qT)),所以 C − P 比右边大同样的数。

估算:put 的 Delta = −e^(−qT)·N(−d1),算出约 −0.373,所以 N(−d1) ≈ 0.375;1 − e^(−qT) ≈ qT = 0.02 × 60/365 ≈ 0.0033。相差约 180 × 0.375 × 0.0033 ≈ 0.22。运行得 0.2214,比容差 1e-8 大七个数量级。差分测试对 put 也跑一遍,所以同样失败:put 的价格错了,bs_delta 给出的 put Delta 却没有改,两者对不上。这组输入的有限差分 Delta 约 −0.364,bs_delta 是 −0.373,相差约 0.009,比容差 1e-5 大近三个数量级。如果差分测试只查 call,这个错误就只有平价测试能发现。pytest 在 SPY 一组就会报错;只有 q = 0 的 NVDA 一组能通过。

(b) 差分测试失败,平价测试通过:平价关系里没有 Vega。差分测试的 Delta、Gamma 两行通过,Vega 一行失败。这组输入每 1 个 IV 点的 Vega 是 0.2758;删掉 / 100 以后,bs_vega 返回 27.58,两者相差约 −27.30,正好是 −99 × 0.2758。

项目 2:iv.py——用 Brent 法求隐含波动率

Section titled “项目 2:iv.py——用 Brent 法求隐含波动率”
  • 输入:期权价格(每股,美元)和 bs.py 除 sigma 以外的六个输入;搜索区间 lo、hi(小数,默认 0.01% 到 500%)。
  • 输出:IV(小数,0.5050 就是 50.5%);价格在无套利区间之外时报错。
  • 假设:与 bs.py 相同;每张期权单独求一个 IV。
  • 检查:把求出的 IV 代回 bs_price,应当得回原价(训练题 6 的「IV 往返」);价格在区间之外时,程序必须报错,而不是给出一个数。

求 IV 就是解一个方程:找到一个 σ,使模型价格等于市场价格。布伦特法(Brent’s method,下文写 Brent 法)先给出一个包含答案的区间(这里是 0.01% 到 500%),再不断缩小这个区间。只要区间两端的误差一正一负,答案就一定在区间之内,所以它一定收敛。

500% 的上限通常够用,但并非总是够用。如果真实的 IV 超过上限,区间两端的误差同号,brentq 就会直接报错。13.3 的二元事件 IV 已经约为 460%,临近到期的期权还可能更高。遇到这种情况,就把上限 hi 调高(例如 10.0,也就是 1000%)再求解。不用更快的牛顿法,是因为牛顿法每一步都要除以 Vega。深度虚值或深度实值期权的 Vega 接近 0,初值不好时,除以它会使步长变得极大,迭代可能发散。

求解之前,先检查价格是否在无套利区间(no-arbitrage bounds)之内,也就是期权价格必须落在其中的上下限。以 call 为例,σ 趋于 0 时,call 的价格趋于下限 max(S·e^(−qT) − K·e^(−rT), 0);σ 趋于无穷大时,趋于上限 S·e^(−qT)。put 的两个限反过来写。σ 从 0 增大到无穷大时,模型价格从下限连续上升到上限,所以区间外的价格没有对应的 IV。这种价格通常说明报价过期、中间价不可成交,或者股息、利率等输入与实际不符(例如期内有一次大额股息)。

# iv.py:用 Brent 法由期权价格反求隐含波动率
import numpy as np
from scipy.optimize import brentq
from bs import bs_price
def implied_vol(price, S, K, T, r, q, cp, lo=1e-4, hi=5.0):
# 先检查价格是否在无套利区间内;区间外不存在对应的 IV
fwd, pv_k = S * np.exp(-q * T), K * np.exp(-r * T)
lower = max(fwd - pv_k, 0) if cp == "c" else max(pv_k - fwd, 0)
upper = fwd if cp == "c" else pv_k
if not lower < price < upper:
raise ValueError(f"价格 {price} 不在 ({lower:.2f}, {upper:.2f}) 之内")
return brentq(lambda s: bs_price(S, K, T, r, q, s, cp) - price, lo, hi, xtol=1e-10)
if __name__ == "__main__":
print(f"NVDA 300C:{implied_vol(0.35, 225, 300, 30/365, 0.04, 0.0, 'c'):.4f}")
quotes = {725: 2.99, 740: 4.86, 745: 5.72, 750: 6.58, 770: 12.32} # SPY 30 天 put 中间价
ks = np.array(list(quotes))
ivs = np.array([implied_vol(p, 770, k, 30/365, 0.04, 0.012, "p") for k, p in quotes.items()])
print(dict(zip(ks.tolist(), ivs.round(4).tolist())))
a, b, c = np.polyfit(np.log(ks / 770), ivs, 2) # 微笑拟合:IV ≈ a·x² + b·x + c
print(f"拟合:a={a:.3f} b={b:.3f} c={c:.4f};K=735 处 IV≈{a*np.log(735/770)**2 + b*np.log(735/770) + c:.4f}")

输出:

NVDA 300C:0.5050
{725: 0.2, 740: 0.1849, 745: 0.18, 750: 0.173, 770: 0.15}
拟合:a=-2.093 b=-0.959 c=0.1499;K=735 处 IV≈0.1901
  • NVDA 300C 报价 $0.35,反解出的 IV 约 50.5%,与第2章训练题 6 的「约 50%」一致。
  • SPY 各 put 的中间价反解回 17.3%、18.0%、18.5%、20%,正是课程的示例偏斜。这五个价格是按示例偏斜算出的模型价,故意没有按 $0.05 的最小报价单位取整,所以能反解回整齐的 IV。
  • 最后一行用二次函数拟合微笑,再插值出没有报价的 735 行权价的 IV,约 19.0%。
  • 拟合只在数据范围之内可信。a 为负,所以这条抛物线开口向下,顶点在 x = −b ÷ 2a ≈ −0.229(x 是代码里的 ln(K ÷ 770),即行权价相对现价的对数距离),即行权价约 770 × e^(−0.229) ≈ 612。因此,外推到约 610 以下的行权价时,拟合的 IV 会转而向下弯曲,而现实的偏斜不会这样。
二次拟合的外推 · SPY 30 天 put 的 IV

求 IV 之前先查价格是否在无套利区间内,再用 Brent 法在两端误差异号的区间里求解,答案在区间里就一定收敛。 报错时先查价格,确认价格没有问题,再调高上限。

项目 3:mc_pnl.py——蒙特卡洛盈亏与 VaR、CVaR

Section titled “项目 3:mc_pnl.py——蒙特卡洛盈亏与 VaR、CVaR”
  • 输入:起始股价 S0、T(年)、sigma(小数)、模拟条数 n、随机种子 seed;跳空的概率 jump_prob 和幅度 jump(小数,−0.10 就是下跌 10%);两个结构的行权价和权利金写在函数里。
  • 输出:每组的到期盈亏(美元,已乘 100)的均值、95% VaR、95% CVaR 和最差值。
  • 假设:到期价格服从对数正态分布,只用一个波动率(15%),没有偏斜和肥尾;跳空只在设定 jump_prob 时加入;持有到期,中途不平仓。
  • 检查:同一个种子重跑,数字完全相同;铁鹰的最差结果不能低于它的最大亏损 −$1,120。

蒙特卡洛模拟(Monte Carlo simulation)用随机数生成成千上万种可能的到期价格,逐个计算盈亏,再观察盈亏的分布。下面的代码用到三个概念。

风险价值(Value at Risk,VaR)是在给定的持有期和模型下,「最差 5% 的情景」的亏损分界线;本节的持有期是持有到期。例如 95% VaR 为 $2,767,意思是只有 5% 的情景亏损超过 $2,767。

条件风险价值(Conditional VaR,CVaR,也叫 expected shortfall)是最差 5% 情景的平均亏损。VaR 只说明尾部从哪里开始,CVaR 还衡量尾部里平均亏损多少,也就是「坏起来有多坏」,所以它比 VaR 更能反映尾部风险。

随机种子(random seed)固定随机数的起点,使每次运行的结果都相同,这样别人才能重现你的数字。

下面比较空头宽跨式和铁鹰。空头宽跨式没有翼,亏损没有上限,在这里只作对照;学习阶段不裸卖(9.8)。

# mc_pnl.py:蒙特卡洛模拟到期盈亏,比较空头宽跨式与铁鹰(每组,美元)
import numpy as np
def terminal_prices(S0, T, sigma, n, r=0.04, q=0.012, jump_prob=0.0, jump=-0.10, seed=42):
rng = np.random.default_rng(seed)
z = rng.standard_normal(n)
ST = S0 * np.exp((r - q - 0.5 * sigma**2) * T + sigma * np.sqrt(T) * z)
hit = rng.random(n) < jump_prob # 哪些路径在期间内发生一次跳空
return np.where(hit, ST * (1 + jump), ST)
def short_strangle(ST): # 卖 740P(4.85)+ 卖 800C(2.90)
return 100 * (7.75 - np.maximum(740 - ST, 0) - np.maximum(ST - 800, 0))
def iron_condor(ST): # 再买 725P(3.00)+ 815C(0.95)当翼
wings = np.maximum(725 - ST, 0) + np.maximum(ST - 815, 0)
return short_strangle(ST) + 100 * (wings - 3.95)
def var_cvar(pnl, level=0.95):
cut = np.quantile(pnl, 1 - level) # 最差 5% 的分界线
return -cut, -pnl[pnl <= cut].mean() # 用正数表示亏损
if __name__ == "__main__":
ST = terminal_prices(770, 30/365, 0.15, n=200_000) # 先不加跳空
for name, f in [("宽跨式", short_strangle), ("铁鹰", iron_condor)]:
pnl = f(ST)
var, cvar = var_cvar(pnl)
print(f"{name}:均值 {pnl.mean():+.0f} 95% VaR {var:.0f} 95% CVaR {cvar:.0f} 最差 {pnl.min():.0f}")

输出(20 万条路径,σ 15%,不加跳空):

宽跨式:均值 +106 95% VaR 2767 95% CVaR 4080 最差 -14857
铁鹰:均值 -14 95% VaR 1120 95% CVaR 1120 最差 -1120

这组输出可以这样读:

  • 铁鹰的最大亏损是 (翼宽 15 − 净收 3.80) × 100 = $1,120,净收是 7.75 − 3.95。约 18% 的情景落在翼外,多于 5%,所以最差的 5% 全部被翼「封顶」,VaR 和 CVaR 都等于 $1,120。
  • 宽跨式的 CVaR 是 $4,080,最差的情景亏损近 $15,000。宽跨式没有翼,亏损没有封顶,所以左尾很长。
  • 宽跨式的均值为正(+$106),原因在模型:模拟按 15% 的实现波动率生成价格路径,不分行权价,也没有偏斜;而卖出的 740P 是按 18.5% 的偏斜 IV 定价的。模拟的结果取决于假设,宽跨式的正均值来自模型没有偏斜、没有肥尾,不能当作真正优势的证据。
  • 函数里预留了 jump_prob(期间内发生一次跳空的概率)和 jump(跳空幅度)两个参数。把 jump_prob 改成 0.02 或 0.05 再运行,比较两个结构的 CVaR 如何变化,这就是训练题 7。提示:先考虑铁鹰的最大亏损是由什么锁定的。

最差 5% 的情景:宽跨式最多亏损近 $15,000,铁鹰全部停在 $1,120

mc_pnl.py:20 万条路径,σ 15%,不加跳空 · 亏损记作正数(每组,美元)

宽跨式没有翼 · 最差亏损近 $15,000

最差 5% 的情景最差 5%VaR $2,767CVaR $4,080

铁鹰VaR = CVaR = 最大亏损 $1,120

  • 亏损超过 VaR 的 5% 情景

VaR 是最差 5% 情景的分界线,CVaR 是这 5% 的平均亏损。铁鹰约 18% 的情景落在翼外,多于 5%,所以最差的 5% 全部被翼「封顶」;宽跨式没有翼,亏损没有封顶,所以左尾很长。

VaR 与 CVaR · 宽跨式与铁鹰

增加模拟条数只能减少随机误差,也就是换一个种子时结果的波动;它改变不了模型里没有偏斜、没有跳空这件事。所以报告模拟结果时,要同时写明种子、条数和这几条假设。

项目 4:event_vol.py——从两个到期日提取事件波动率

Section titled “项目 4:event_vol.py——从两个到期日提取事件波动率”
  • 输入:到期时间(年,4 天写 4/365)和年化 IV(小数);近月法另要一个基准 IV。
  • 输出:事件波动率 m(小数,按 1σ 计的一次性涨跌幅)和基准 IV;按正态分布近似,0.8m 是预期绝对涨跌幅,涨跌分布偏向两端时它会低估。基准 IV 指不含这次事件的普通日子的 IV,m 和 0.8m 的含义与推导见 13.3。
  • 假设:期间只有一次事件;两期法还假设普通日子的方差在两个到期日里相同。
  • 检查:近月法和两期法互相核对,再与 13.3 的手算结果核对。
# event_vol.py:从期限结构提取一次性事件波动率(全部用年化 IV、以年计的 T)
from math import sqrt
def event_move_front(T_front, iv_front, iv_normal):
"""只用近月:需要另外给出不含事件的基准 IV。"""
return sqrt(T_front * (iv_front**2 - iv_normal**2))
def event_move_two(T1, iv1, T2, iv2):
"""两个都包含事件的到期日:同时解出基准 IV 与事件波动率 m。"""
var_normal = (iv2**2 * T2 - iv1**2 * T1) / (T2 - T1) # 普通日子的年化方差
m = sqrt((iv1**2 - var_normal) * T1)
return m, sqrt(var_normal)
if __name__ == "__main__":
m = event_move_front(4/365, 0.91, 0.40)
print(f"近月法:m = {m:.4f},预期绝对涨跌幅 ≈ {0.8 * m:.4f}")
m2, base = event_move_two(4/365, 0.91, 32/365, 0.494)
print(f"两期法:m = {m2:.4f},基准 IV = {base:.4f}")

输出:

近月法:m = 0.0856,预期绝对涨跌幅 ≈ 0.0685
两期法:m = 0.0855,基准 IV = 0.4007

近月法就是 13.3 的公式,需要另外给出基准 IV。两期法用两个都包含事件的到期日联立求解:每个到期日的总方差,等于普通日子的方差加上事件的方差,两式相减消去 m²,就解出普通日子的方差(公式和推导见 13.3 的两个到期日的版本)。代码里 var_normal 一行就是相减的结果,m 一行是把它代回较近的到期日求出 m。

两种方法的结果几乎相同(m 分别为 0.0856 与 0.0855):两期法从 32 天的到期日解出的基准 IV 是 40.07%,与近月法假设的 40% 只差 0.07 个点,说明 13.3 的例子前后自洽。两期法用「普通日子的方差在两个到期日里相同」这一假设代替另外估计基准 IV,代码算出的 m 要与近月法和手算互相核对。

项目 5:scalp_sim.py——Gamma scalping 的结果分布

Section titled “项目 5:scalp_sim.py——Gamma scalping 的结果分布”
  • 输入:实现波动率 realized(小数);跨式的 S0、K、天数、IV(小数);路径数 n、种子 seed。
  • 输出:每股结果(美元)的均值、标准差和亏损路径的比例;乘以 100 是每组。
  • 假设:每天收盘对冲一次,对冲没有交易成本;IV 在 30 天里不变;股价以实现波动率按对数正态分布运动。
  • 检查:均值约等于 Vega × (实现波动率 − IV);实现波动率等于 IV 时,均值约为 0。

9.6 讲过,买入跨式并按 Delta 对冲,盈利来自「实现波动率 − IV」。下面的模拟考察这种交易在不同实现波动率下的结果分布。

# scalp_sim.py:买入平值跨式、每天收盘做一次 Delta 对冲,看结果分布(每股)
import numpy as np
from bs import bs_price, bs_delta
def scalp_pnl(realized, n=20_000, S0=340.0, K=340.0, days=30, iv=0.25, r=0.04, q=0.003, seed=7):
rng, dt = np.random.default_rng(seed), 1 / 365
value = lambda S, T: bs_price(S, K, T, r, q, iv, "c") + bs_price(S, K, T, r, q, iv, "p")
delta = lambda S, T: bs_delta(S, K, T, r, q, iv, "c") + bs_delta(S, K, T, r, q, iv, "p")
S, pnl = np.full(n, S0), np.zeros(n)
for d in range(days):
T = (days - d) * dt
z = rng.standard_normal(n)
S_new = S * np.exp((r - q - 0.5 * realized**2) * dt + realized * np.sqrt(dt) * z)
V_new = np.abs(S_new - K) if d == days - 1 else value(S_new, T - dt)
# 当天盈亏 = 跨式价值的变化 − 对冲股票的变化 − 占用资金的利息
pnl += (V_new - value(S, T)) - delta(S, T) * (S_new - S) - r * dt * (value(S, T) - delta(S, T) * S)
S = S_new
return pnl
if __name__ == "__main__":
for rv in (0.30, 0.25, 0.20):
p = scalp_pnl(rv)
print(f"实现波动率 {rv:.0%}:均值 {p.mean():+.2f} 标准差 {p.std():.2f} 亏损路径的比例 {np.mean(p < 0):.0%}")

输出(每股,2 万条路径,每天对冲一次):

实现波动率 30%:均值 +3.88 标准差 3.98 亏损路径的比例 13%
实现波动率 25%:均值 +0.00 标准差 3.03 亏损路径的比例 50%
实现波动率 20%:均值 -3.88 标准差 2.74 亏损路径的比例 94%

均值约等于 Vega × (实现波动率 − IV)。平值跨式的 Vega 约 0.78,实现波动率比 IV 高 5 个点,所以均值 ≈ 0.78 × 5 ≈ $3.9,与第9章训练题 5 一致。然而,即使实现波动率(30%)高于 IV(25%),仍有约 13% 的路径亏损。结果高度依赖路径,即使实现波动率高于 IV,单次交易也可能亏损,一次交易说明不了什么。

项目 6:backtest/——成交价假设决定回测结果

Section titled “项目 6:backtest/——成交价假设决定回测结果”
  • 输入:组合报价 bid、ask(每股,美元);方向 side("buy" 或 "sell");成交假设 mode("natural"、"mid" 或 "midpoint")。
  • 输出:这一次成交按每股记多少(美元);乘以 100 和组数就是金额。
  • 假设:报价代表当时能成交的价格;佣金另外减去(12.6)。
  • 检查:卖出时自然价 ≤ 中点 ≤ 中间价,买入时反过来;mode 拼错时报错。

回测的陷阱和成交价假设在 12.6 讲过,这里用代码把三种假设的差别算出来。代码里的三种 mode 对应三个价格:

  • natural:自然价(见 7.0 节),买在卖价、卖在买价,也就是可以立即成交的价格;多腿组合用组合自然价(见 8.1 节)。
  • mid:按中间价成交,即 12.6 的中间价成交假设;现实中多腿组合常常做不到。
  • midpoint:中间价与自然价的中点。模拟盘按中点记账,这是 12.6 模拟盘协议第 1 条的记账价:多腿组合挂在中间价常常成交不了,按中间价记账会高估盈利;按自然价记又过于保守,因为限价单通常能比自然价好一些。
# backtest/fills.py:三种成交价假设
def fill_price(bid, ask, side, mode="natural"):
"""side:'buy' 或 'sell';bid、ask 是组合报价(每股)。
natural:自然价,买在卖价、卖在买价;mid:中间价;
midpoint:中间价与自然价的中点(12.6 模拟盘协议第 1 条的记账价)。"""
natural = ask if side == "buy" else bid
mid = (bid + ask) / 2
if mode == "natural":
return natural
if mode == "mid":
return mid
if mode == "midpoint":
return (natural + mid) / 2
raise ValueError(f"未知的成交假设:{mode}")
if __name__ == "__main__":
# 例:卖出 10 组铁鹰,组合报价 bid 1.80 / ask 3.00
for mode in ("natural", "mid", "midpoint"):
credit = fill_price(1.80, 3.00, "sell", mode)
print(f"{mode}:每组收 {credit:.2f},10 组共 ${credit * 100 * 10:,.0f}")

运行 python fills.py 的输出:

natural:每组收 1.80,10 组共 $1,800
mid:每组收 2.40,10 组共 $2,400
midpoint:每组收 2.10,10 组共 $2,100

同一笔交易,仅仅因为成交假设不同,结果就相差 $600(第9章训练题 9):每组相差 2.40 − 1.80 = $0.60,10 组共 $600。中点 $2,100 正好在两者中间,比中间价少记 $300。这里用 10 组只为放大差别,你自己下单时,组数照 11.2 的新仓定组数定。

最后的 mode 检查不能省。少了它,把 "midpoint" 拼成 "midpiont",函数会悄悄按自然价返回,回测照样跑出一个数,你却以为看到的是中点。测试写在 backtest/test_fills.py 里:

# backtest/test_fills.py:三种假设的大小顺序不能乱
import pytest
from fills import fill_price
def test_order_of_fills():
for bid, ask in [(1.80, 3.00), (0.05, 0.10)]:
sell = [fill_price(bid, ask, "sell", m) for m in ("natural", "midpoint", "mid")]
buy = [fill_price(bid, ask, "buy", m) for m in ("natural", "midpoint", "mid")]
assert sell == sorted(sell) # 卖出:自然价 ≤ 中点 ≤ 中间价
assert buy == sorted(buy, reverse=True) # 买入:自然价 ≥ 中点 ≥ 中间价
def test_unknown_mode():
with pytest.raises(ValueError):
fill_price(1.80, 3.00, "sell", "midpiont") # 拼错了要报错,不能悄悄按自然价算

with pytest.raises(ValueError): 的意思是「下面这一行必须报出 ValueError」,不报错,测试反而失败。在 backtest/ 文件夹里运行 pytest,两个测试都通过。

完整的回测是把 fill_price 放进一个循环。先定一个简单的规则策略,例如每月在固定时间开一组约 45 天的铁鹰,盈利达到 50% 或剩 21 天时离场(10.3 的两条规则);每次开仓、平仓各调用一次 fill_price,三种假设各记一份账,再减去佣金。一年开仓 12 次,每次开仓和平仓各成交一次,三份账的差距会累积得很大。回测按中间价记账会高估盈利,所以要同时报告自然价、中间价和中点三种结果,模拟盘按中点记账。 12.6 列出的其他陷阱(前视偏差、幸存者偏差、提前指派、数据缺口、过拟合)也要防范。历史期权链数据通常需要付费购买,免费数据大多只有指数、VIX 等的收盘值。

示范:这次 NVDA 财报卖铁鹰,尾部风险多大

Section titled “示范:这次 NVDA 财报卖铁鹰,尾部风险多大”

把几个工具串起来,回答一个问题(示例价格,非实时):「这次 NVDA 财报,卖出一个铁鹰的尾部风险有多大?」

  1. iv.py:从财报前一天的期权链快照中,反解出 4 天与 32 天到期的平值 IV:91% 与 49.4%。
  2. event_vol.py:用两期法得到 m ≈ 8.55%、基准 IV ≈ 40%,预期绝对涨跌幅约为 0.8 × 8.55% ≈ 6.8%。
  3. mc_pnl.py:把 terminal_prices 改成「普通日子的波动 + 一次事件跳动」,事件跳动按 1σ = m 的正态分布抽样,再把行权价换成你设计的铁鹰,输出盈亏分布、95% VaR 与 CVaR。铁鹰的净收用 fills.py 按自然价取,不按中间价。
  4. 定组数:财报在盘后公布,跳空可以直接越过翼,所以事件交易的每组风险按亏满算(9.7),铁鹰每组亏满 = (翼宽 − 净收) × 100。再按新仓定组数(11.2),组数 = 单笔上限 ÷ 每组亏满,向下取整。例如净值 $100,000、单笔上限 2%($2,000)、每组亏满 $340 时,2,000 ÷ 340 ≈ 5.9,最多开 5 组(示例数据)。VaR 和 CVaR 不改变组数,它们回答另一个问题:亏满的可能有多大。95% CVaR 已经等于每组亏满,说明最差的 5% 情景全都亏满。
  5. 交叉检查:bs.py 的测试应全部通过,两期法的 m 也应与 13.3 手算的 8.6% 一致。任何一步的结果不一致,先检查代码,再检查数据。

随堂练习(示例价格,非实时):换一组新的输入,先手算或预测,再运行核对。

(a) iv.py:一只股票 S = 180,45 天到期的 160C,r = 4%,q = 2%。报价分别是 $20.10、$21.50、$23.00。哪一个会报错,为什么?另外两个,哪一个的 IV 更高?运行核对,再把求出的 IV 代回 bs_price。

(b) event_vol.py:同一次财报,6 天后到期的平值 IV 68%,34 天后到期的 41%,两个到期日都包含财报。照 event_move_two 的两行代码手算基准 IV 和 m,再运行核对。如果你另外估计的基准 IV 是 35%,近月法给出的 m 是多少?

(c) fills.py:你按规则卖出 3 组牛市看跌价差(组数已按 11.2 定好),开仓时组合报价 1.15 / 1.45;后来买回平仓,组合报价 0.40 / 0.60。按自然价、中间价和中点分别算出这笔交易的盈亏(不计佣金)。中间价比自然价多记了多少?

参考解答

(a) 先算无套利区间的下限:S·e^(−qT) − K·e^(−rT) = 180 × e^(−0.02 × 45/365) − 160 × e^(−0.04 × 45/365) ≈ 179.56 − 159.21 ≈ $20.34。$20.10 低于下限,程序报错「价格 20.1 不在 (20.34, 179.56) 之内」。注意 $20.10 高于内在价值 180 − 160 = $20,仍然低于下限:行权价按利率贴现,股价按股息率贴现,r > q,所以下限比内在价值高。另外两个价格在区间内,价格越高 IV 越高:$21.50 对应 0.3026,$23.00 对应 0.4047。把这两个 IV 代回 bs_price,得回 21.50 和 23.00,误差在 1e-13 量级。

(b) σn² = (0.41² × 34 − 0.68² × 6) ÷ (34 − 6) = (5.7154 − 2.7744) ÷ 28 ≈ 0.10504,基准 IV ≈ 32.4%。m = √((0.4624 − 0.10504) × 6/365) ≈ √0.005874 ≈ 0.0766,即约 7.7%,预期绝对涨跌幅约 0.8 × 7.66% ≈ 6.1%。运行输出 m = 0.0766、基准 IV = 0.3241。求 σn² 时天数可以直接代入,因为分子分母的单位约掉了;求 m 时,T 要换算成年。基准 IV 取 35% 时,近月法给出 m ≈ 0.0747:基准 IV 估高了 2.6 个点,m 只低了约 0.2 个点。

(c) 开仓是卖出:自然价 1.15,中间价 (1.15 + 1.45) ÷ 2 = 1.30,中点 (1.15 + 1.30) ÷ 2 = 1.225。平仓是买入:自然价 0.60,中间价 0.50,中点 0.55。每组盈亏分别是 1.15 − 0.60 = 0.55、1.30 − 0.50 = 0.80、1.225 − 0.55 = 0.675;乘以 100 和 3 组:自然价 $165,中间价 $240,中点 $202.50。中间价比自然价多记 $75 = 3 × 100 × (0.15 + 0.10):开仓和平仓各让出半个买卖价差,一进一出都要算。

项目交付以前,逐条核对:

  1. 单位:IV、利率、股息率写成小数(15% 写 0.15);T 换算成年(30 天写 30/365);bs.py 的价格是每股,乘以 100 才是每张;盈亏函数写明是否已乘 100。
  2. 每个文件开头的注释写明输入、输出、单位和它依赖的假设。
  3. pytest 全部通过,至少包括训练题 6 的 5 个测试;平价误差小于 1e-8,差分测试对 call 和 put 都跑一遍,测试用例里至少有一组 q > 0。
  4. python bs.py 的输出与课程的 14.08 / 12.32 一致。
  5. 随机模拟都固定了种子,重跑一次数字完全相同;报告里写明种子和模拟条数。
  6. iv.py 先查无套利区间;求解报错时,先查价格,再考虑调高上限 hi。
  7. 回测同时报告自然价、中间价和中点三种结果,并减去佣金。
  8. 每个项目的说明里至少写一条已知局限,例如没有偏斜、没有跳空、对冲没有成本。

常见误区:

  • 「代码跑出了数字,就说明是对的。」——没有测试的代码只是「看起来对」。平价测试和有限差分测试能发现大部分公式错误;单位错误还要与已知数字核对。
  • 「平价测试通过了,定价公式就没有错。」——平价关系对任何 d1、d2 都成立,d1 写错时它照样通过;这类错误要靠有限差分测试发现。
  • 「模拟次数越多,结果就越接近真相。」——增加次数只能减少随机误差。如果假设错了(没有偏斜、没有跳空),即使运行一亿次,结果也是错的。
  • 「求 IV 用牛顿法最快,所以最好。」——深度虚值或深度实值时 Vega 接近 0,牛顿法在初值不好时可能发散;Brent 法慢一些,但只要区间两端异号就一定收敛。
  • 「回测按中间价成交就好。」——多腿策略按中间价记账会大幅高估盈利,所以要同时报告自然价、中间价和中点三种结果;模拟盘按中点记账(12.6)。
  • 「拟合出来的微笑曲线可以随便外推。」——二次拟合在数据范围之外,可能弯向完全错误的方向,所以只能在有报价的范围内使用。

思考题:

  1. 为什么求 IV 之前,要先检查价格是否在无套利区间内?(答:σ 从 0 增大到无穷大时,模型价格只在无套利区间之内变化,所以区间外的价格没有任何 σ 能对应,求解器会报错或给出错误的值。这种价格通常说明报价过期、中间价不可成交,或者股息、利率等输入与实际不符(例如期内有一次大额股息)。)
  2. 平价测试的误差是 1e-3,可以接受吗?(答:不可以。测试要求误差小于 1e-8,正确的实现实测不超过 1e-13;误差达到 1e-3,说明公式、股息项或贴现项写错了。)
  3. 项目 5 里,实现波动率等于 IV(25%)时均值为 0,但标准差仍有 $3.03。这说明什么?(答:即使定价公平,单次对冲交易的结果也会大幅偏离期望。所以需要看很多次交易的平均结果,才能判断是否有优势。)
  4. 把 mc_pnl.py 的 n 从 20 万改成 2,000,种子依次取 1 到 5,各运行一次。宽跨式的 95% VaR 在什么范围内变化?铁鹰呢?这说明模拟条数解决的是什么问题?(答:宽跨式的 95% VaR 在约 $2,590 到 $2,820 之间变化;n 取 20 万时,同样五个种子都在约 $2,720 到 $2,750 之间。铁鹰五次都是 $1,120,因为最差的 5% 都落在翼外的封顶亏损上。增加条数只缩小随机误差;模型里没有偏斜和跳空,条数再多也改变不了。)

本节要点:

  1. 没有测试的代码只是看起来对,所以定价代码要通过两个测试:平价误差小于 1e-8;call 和 put 的 Delta、Gamma、Vega 都与有限差分一致。
  2. 平价测试发现价格公式里的符号、股息项和贴现项错误,发现不了 d1、d2 里的错误,这类错误和希腊字母公式的错误要靠对 call 和 put 都做的有限差分测试。
  3. 求 IV 之前先查价格是否在无套利区间内,再用 Brent 法在两端误差异号的区间里求解,答案在区间里就一定收敛。
  4. 模拟的结果取决于假设,宽跨式的正均值来自模型没有偏斜、没有肥尾,不能当作真正优势的证据。
  5. 两期法用「普通日子的方差在两个到期日里相同」这一假设代替另外估计基准 IV,代码算出的 m 要与近月法和手算互相核对。
  6. 结果高度依赖路径,即使实现波动率高于 IV,单次交易也可能亏损,一次交易说明不了什么。
  7. 回测按中间价记账会高估盈利,所以要同时报告自然价、中间价和中点三种结果,模拟盘按中点记账。

本节任务:装好 Python 3.10 和四个库,建好 options/ 文件夹,抄写 bs.py 和 test_bs.py。运行 python bs.py,核对输出是 14.08 / 12.32 和 0.529 / 0.0120 / 0.877;再运行 pytest,两个测试都通过。约 15 分钟。

关键术语:

中文 English 释义
单元测试 unit test 用已知答案检查一段代码的结果是否正确的小测试
有限差分 finite difference 把输入改变一个很小的量后重算,用输出的变化量近似导数
蒙特卡洛模拟 Monte Carlo simulation 用大量随机情景估计结果的分布
风险价值 value at risk(VaR) 在给定持有期和模型下,最差 5%(或 1%)情景的亏损分界线
条件风险价值 CVaR / expected shortfall 最差的那部分情景(如最差 5%)的平均亏损

项目卡

参考学时
约 32 小时
先修回顾
0.6–0.8;2.7;2.8;11.5;12.6
项目产出
六个小项目的代码,每个附单元测试。

问 AI 导师

卡住了,或者想换个角度再学一遍?把下面这段提示词交给 Claude 或其他 AI 助手,它会按本课程的教学规则一对一带你学这一节。提示词可以先改再复制。

AI 也会算错:它给的数字请自己复算,拿不准时以正文和答案页为准。

仅供学习,不构成投资建议。课程里的价格和数据都是标注过的示例,不是实时行情。