导论及思维导图

课时目标：学习目标：掌握期权的基本概念，期权定价的无套利定价原理和风险中性原理；理解欧式期权的平价公式；可以应用二叉树模型计算期权的价值。

9.1 期权的基本概念

期权的基本概念：

  • 期权：买卖资产的权利。规定期限，约定价格，一定数量。
  • 期权多头：期权买方、期权持有人，获得权利。
  • 期权空头：期权卖方。根据买方要求，履行义务。
  • 执行价格：买卖资产的价格即期权合约中标的资产的交易价格
  • 期权费（期权价格）：为了获得权利，多头向空头支付的费用，这是合约本身的价格

期权的类型：

  • 看涨期权（call）：以执行价格买入标的资产的权利。例：在12月20日，以每股20元的价格，购买1万股A公司的股票。资产价格上涨越多，看涨期权的价值越大。
  • 看跌期权（put）：以执行价格卖出标的资产的权利。例：在12月20日，以每股30元的价格，出售1万股B公司的股票。资产价格下跌越多，看跌期权的价值越大。

期权的行权方式：

  • 欧式期权：只能在到期日行使权利。
  • 美式期权：可在到期前的任何日期执行期权。

注：美式期权的价值不低于相应欧式期权的价值。

根据市场价格和执行价格的关系，期权可以划分为实值期权、虚值期权和平价期权。实值期权是市场价格大于执行价格的期权，虚值期权是市场价格小于执行价格的期权，平价期权是市场价格等于执行价格的期权。

以看跌期权为例则结果相反。

9.2 期权的回收和盈亏

期权的回收是指期权到期时能够带来的现金价值，通过减去支付的期权费得到盈亏。

看涨期权多头的回收和盈亏取决于资产价格和执行价格之间的差额，如果资产价格上涨，期权会带来正的收益。

而看跌期权多头的回收和盈亏取决于资产价格和执行价格之间的差额，如果资产价格下跌，期权会带来正的收益。

通过计算回收和减去期权费的终值，可以得到期权的盈亏。盈亏图可以用来分析不同市场价格下的盈亏情况。

9.3 欧式期权的平价关系

首先给出了一组符号，包括时间零点、期权合约的到期时间、无风险连续复利、标的资产的价格和执行价格。

欧式期权的平价关系是指看涨期权的价格减去看跌期权的价格等于标的资产价格减去执行价格的现值。

为了证明这个关系，构造了两个投资组合A和B，并分析了在期权合约到期的两种情况下它们的价值相等。根据无套利定价原理，组合A和组合B在当前时刻的价值也应该相等。因此，可以建立看涨期权和看跌期权之间的平价关系。

当远期价格大于执行价格时，看涨期权更加值钱，而看跌期权相对便宜。

9.4 美式期权的价格关系

对于欧式期权而言，看涨期权的价格与看跌期权的价格存在平价关系。但是对于美式期权而言，这种平价关系不存在。然而，美式看涨期权的价格与看跌期权的价格仍然具有一定的规律性。

我们解释了为什么美式看涨期权不会被提前执行，以及美式看跌期权有可能被提前执行。在期权交易中，如果标的资产在期权合约到期之前不会产生收益，那么美式看涨期权和欧式看涨期权是等价的。对于美式期权而言，看涨期权的价格减去看跌期权的价格大于等于标的资产价格减去执行价格，小于等于标的资产价格减去执行价格的现值。如果标的资产有分红，那么可以将原来的价格关系中的标的资产替换为标的资产减去红利的现值，新的价格关系仍然成立。

9.5 期权定价基本原理

在期权定价中，主要使用无套利定价法，它有不同的表现形式。其中一种是复制技术，通过构造一个资产组合，使其回收和期权的回收相等，从而得到期权的价值。另一种表现形式是风险中性定价法，将现实测度转化成风险中性测度，使用无风险利率来计算未来现金流的期望现值，简化计算过程。

无套利定价原理：

  • 两个资产的终值相等，现值也必相等
  • 复制技术：如果资产组合可以复制期权的回收，则期权的价值等于组合的价值
  • 风险中性定价：在风险中性测度下，用无风险利率计算未来现金流的期望现值

通过一个例子解释了无套利定价法的基本原理，假设股票价格只有两种变化可能，根据股票价格的变化情况，构造一个资产组合，解出资产组合在时间零点的价值，即为期权的价值。

另外，介绍了风险中性定价法，假设股票的期望收益率等于无风险利率，计算出股票价格上升和下跌的概率，进而计算出期权的期望值，并将其折现到时间零点，得到期权的价值。

9.6 单步二叉树模型

单步二叉树模型是指在期权合约有效期内，股票价格只发生一次变化，即股价要么上升到110元，要么下降到90元。根据无套利定价法，构造一个无风险的资产组合，其中包含0.5个单位的股票和1个单位的看涨期权空头。根据组合的价值变化，可以计算出看涨期权的价值。通过解方程，得到看涨期权的价值为9.09元。

9.7 单步二叉树模型

首先构造一个无风险的资产组合，包含w单位的股票和1单位的看涨期权空头。股票价格上升到uS或下降到dS后，组合的价值分别为wuS-fu和wdS-fd。根据无风险假设，组合的价值在股票价格上升和下降后保持不变。根据这个条件，可以得到一个方程，解出股票的数量w。根据无风险组合的价值不变，可以计算出股票的数量w。根据无风险假设，组合的收益率为无风险利率。根据这些条件，可以计算出期权的价格f。最后，介绍了计算u和d的方法，其中u=e的σ乘以根号T，d为u的倒数。的一般形式。

例子：假设股票不支付红利，当前价格为10元，在3个月以后，股票价格要么是12元，要么是8元。该股票欧式看涨期权的期限为3个月，执行价格为11元，无风险连续复利为10%。计算该期权的价格。

u=1.2，d=0.8

f=0.55

注意：风险中性概率不是现实世界中的概率

计算u和d的一般方法（Cox， Ross 和 Robinstein， 1979）：

$f=\mathrm{e}^{-rT}\left[pf_u+\left(1-p\right)f_d\right]$

$p=\frac{\mathrm{e}^{r^T}-d}{u-d}$

$u=\mathrm{e}^{\sigma\sqrt{T}}$

$d=\mathrm{e}^{-\sigma\sqrt{T}}$

9.8 多步二叉树模型

多步二叉树模型是单步二叉树模型的推广，通过构造两步二叉树模型来说明。假设股票当前价格为100，上升为原来的1.1倍，下跌为原来的0.91倍。根据这个条件，构造了一个两步二叉树模型，股票价格有三种可能取值：121、100和83。如果给定欧式看涨期权执行价格为100，可以计算出对应的期权价值分别为21、0和0。通过加权平均和贴现，可以计算出期权在时间零点的价值。多步二叉树模型可以进一步推广到更多步骤，通过倒推每个点上的期权价值，最终可以计算出时间零点的期权价值。

9.9 例题：欧式看涨期权的多步二叉树模型

本教学视频介绍了如何使用多步二叉树模型为欧式看涨期权进行定价。视频中通过一个例子来说明定价的过程。首先给出了股票当前的市场价格、股票价格的年波动率、无风险的连续复利以及期权的执行价格等已知条件。然后构造了一个五步的二叉树模型，计算了股票在未来第五个月末的六种可能取值。根据这些股票价格的未来可能取值，计算出了相应价格水平下期权的价值。接着使用加权平均和贴现的方法，逐步倒推计算出了期权在时间零点的价值为3.22元。教学视频通过红色和黑色的表示方式，清晰地展示了股票价格和期权价值的变化过程。

例：欧式看涨期权的二叉树定价模型

  • 股票的当前市场价格为50元，不付红利（S=50)
  • 股票价格的年波动率为20%($\sigma=20%$)
  • 无风险连续复利为5%（r=5%）
  • 该股票5个月期的欧式看涨期权的执行价格为50元
  • 求该期权的价值 （用五步二叉树）

使用二叉树模型计算欧式看涨期权的价格Python代码实现

股票的当前市场价格为100元，股票没有红利;  股票价格的年波动率为10%; 无风险连续复利为6%; 该股票2个月期的欧式看涨期权的执行价格为100元; 求该期权的价值（用2步二叉树模型）。

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59

import numpy as np  
import matplotlib.pyplot as plt  
plt.rcParams['font.sans-serif'] = ['SimHei']  # 用来正常显示中文标签  
plt.rcParams['axes.unicode_minus'] = False  # 用来正常显示负号  
# 参数设定  
S0 = 100  # 当前股票价格  
K = 100   # 执行价格  
sigma = 0.10  # 波动率  
r = 0.06  # 无风险利率  
T = 2 / 12  # 期权期限（2个月）  
steps = 2  # 二叉树步数  
  
# 计算u, d, p  
dt = T / steps  
u = np.exp(sigma * np.sqrt(dt))  # 上涨因子  
d = np.exp(-sigma * np.sqrt(dt))  # 下跌因子  
p = (np.exp(r * dt) - d) / (u - d)  # 风险中性概率  
  
# 计算股票价格树  
stock_prices = np.zeros((steps + 1, steps + 1))  
for i in range(steps + 1):  
    for j in range(i + 1):  
        stock_prices[j, i] = S0 * (u ** (i - j)) * (d ** j)  
  
# 计算期权价值树  
option_values = np.zeros((steps + 1, steps + 1))  
for j in range(steps + 1):  
    option_values[j, steps] = max(0, stock_prices[j, steps] - K)  # 欧式看涨期权  
  
# 反向递推计算期权价值  
for i in range(steps - 1, -1, -1):  
    for j in range(i + 1):  
        option_values[j, i] = np.exp(-r * dt) * (p * option_values[j, i + 1] + (1 - p) * option_values[j + 1, i + 1])  
  
# 输出股票价格树和期权价值树  
print("股票价格树：")  
print(stock_prices)  
print("\n期权价值树：")  
print(option_values)  
  
# 绘制二叉树  
def plot_tree(tree, title):  
    fig, ax = plt.subplots()  
    ax.set_title(title)  
    ax.axis('off')  
  
    for i in range(tree.shape[0]):  
        for j in range(tree.shape[1]):  
            if tree[i, j] != 0:  
                ax.text(j, -i, f"{tree[i, j]:.2f}", ha='center', va='center', bbox=dict(boxstyle="round,pad=0.3", edgecolor='black', facecolor='lightgrey'))  
  
    plt.show()  
  
plot_tree(stock_prices, "股票价格树")  
plot_tree(option_values, "期权价值树")  
  
# 期权的现值  
option_price = option_values[0, 0]  
print(f"\n该看涨期权的价值为: {option_price:.2f}")

代码解释

  1. 参数设定：根据题目设置股票当前价格、执行价格、波动率、无风险利率、期权期限和步数。
  2. 计算u, d, p：使用给定公式计算上涨因子u、下跌因子d和风险中性概率p。
  3. 构建股票价格树：使用双重循环填充股票价格树。
  4. 计算期权价值树：首先在最后一步计算期权价值，然后反向递推计算得到每个节点的期权价值。
  5. 绘制二叉树：使用Matplotlib绘制股票价格树和期权价值树。
  6. 输出期权价值：最后输出期权的现值。

运行上述代码后，会输出股票价格树和期权价值树，并在控制台打印出期权的价值。根据题目要求，最终的看涨期权价值为：

1

该看涨期权的价值为: 1.98

使用二叉树模型计算欧式看跌期权的价格Python代码实现

股票的当前市场价格为100元，股票没有红利;  股票价格的年波动率为10%; 无风险连续复利为6%; 该股票2个月期的欧式看跌期权的执行价格为100元; 求该看跌期权的价值（用2步二叉树模型）。 

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59

import numpy as np
import matplotlib.pyplot as plt
plt.rcParams['font.sans-serif'] = ['SimHei']  # 用来正常显示中文标签
plt.rcParams['axes.unicode_minus'] = False  # 用来正常显示负号
# 参数设定
S0 = 100  # 当前股票价格
K = 100   # 执行价格
sigma = 0.10  # 波动率
r = 0.06  # 无风险利率
T = 2 / 12  # 期权期限（2个月）
steps = 2  # 二叉树步数

# 计算u, d, p
dt = T / steps
u = np.exp(sigma * np.sqrt(dt))  # 上涨因子
d = np.exp(-sigma * np.sqrt(dt))  # 下跌因子
p = (np.exp(r * dt) - d) / (u - d)  # 风险中性概率

# 计算股票价格树
stock_prices = np.zeros((steps + 1, steps + 1))
for i in range(steps + 1):
    for j in range(i + 1):
        stock_prices[j, i] = S0 * (u ** (i - j)) * (d ** j)

# 计算看跌期权价值树
put_option_values = np.zeros((steps + 1, steps + 1))
for j in range(steps + 1):
    put_option_values[j, steps] = max(0, K - stock_prices[j, steps])  # 欧式看跌期权

# 反向递推计算期权价值
for i in range(steps - 1, -1, -1):
    for j in range(i + 1):
        put_option_values[j, i] = np.exp(-r * dt) * (p * put_option_values[j, i + 1] + (1 - p) * put_option_values[j + 1, i + 1])

# 输出股票价格树和看跌期权价值树
print("股票价格树：")
print(stock_prices)
print("\n看跌期权价值树：")
print(put_option_values)

# 绘制二叉树
def plot_tree(tree, title):
    fig, ax = plt.subplots()
    ax.set_title(title)
    ax.axis('off')

    for i in range(tree.shape[0]):
        for j in range(tree.shape[1]):
            if tree[i, j] != 0:
                ax.text(j, -i, f"{tree[i, j]:.2f}", ha='center', va='center', bbox=dict(boxstyle="round,pad=0.3", edgecolor='black', facecolor='lightgrey'))

    plt.show()

plot_tree(stock_prices, "股票价格树")
plot_tree(put_option_values, "看跌期权价值树")

# 期权的现值
put_option_price = put_option_values[0, 0]
print(f"\n该看跌期权的价值为: {put_option_price:.2f}")

代码解释

  1. 参数设定：与之前相同，根据题目设定股票当前价格、执行价格、波动率、无风险利率、期权期限和步数。
  2. 计算u, d, p：使用相同的公式计算上涨因子u、下跌因子d和风险中性概率p。
  3. 构建股票价格树：使用双重循环填充股票价格树。
  4. 计算看跌期权价值树：在最后一步计算看跌期权的价值，公式为 max(0, K - S)，然后反向递推计算得到每个节点的期权价值。
  5. 绘制二叉树：使用Matplotlib绘制股票价格树和看跌期权价值树。
  6. 输出期权价值：最后输出看跌期权的现值。

运行上述代码后，会输出股票价格树和看跌期权价值树，并在控制台打印出期权的价值。根据题目要求，最终的看跌期权价值将会被计算并输出。

1

该看跌期权的价值为: 0.98

9.10 例题：美式看跌期权的多步二叉树模型

美式看涨期权不会被提前执行，所以美式看涨期权的价格等于欧式看涨期权价格。

美式看跌期权可能会被提前执行，所以美式看跌期权的价格不等于欧式看跌期权价格。

在这个教学视频中，我们学习了如何使用二叉树模型为美式看跌期权进行定价。首先，我们需要确定股票价格的变化过程，根据给定的股票价格、波动率和步长，可以计算出股票价格在每个时间点上的值。然后，根据期权合约的执行价格，可以计算出每个时间点上看跌期权的价值。在计算过程中，我们还考虑了期权的提前执行情况，如果股票价格低于执行价格，期权可以被提前执行，相应的价值会更高。通过递推计算，我们最终得到了美式看跌期权在时间零点的价值为2.27。

例子：美式看跌期权的二叉树定价模型

  • 股票的当前市场价格为50元，无红利
  • 年波动率为20%
  • 无风险连续复利为5%
  • 该股票5个月期的美式看跌期权的执行价格为50元
  • 求该期权的价值（用五步二叉树）

9.11 Black-Scholes模型简介

Black-Scholes定价模型在期权定价中具有重要地位，涉及随机过程的理论和方法。在该模型中，欧式看涨期权的价格可以直接计算，与看跌期权的价格存在平价关系。计算欧式看涨期权价格的公式包括标的资产价格、执行价格、无风险利率、股价波动率和合约到期时间。通过计算d1和d2的值，可以得到标准正态分布函数在这两个点的取值。代入Black-Scholes定价公式，可以计算出欧式看涨期权的价格。根据平价关系，可以直接计算出看跌期权的价格。

$C_\text{欧}=S\Phi(d_1)-K\mathrm{e}^{-rT}\Phi(d_2)$

$d_1=\frac{\ln(S/K)+(r+\sigma^2/2)T}{\sigma\sqrt{T}}$

$d_2=\frac{\ln(S/K)+(r-\sigma^2/2)T}{\sigma\sqrt{T}}=d_1-\sigma\sqrt{T}$

例子：假设某种不支付红利股票的市场价格为20元，无风险利率为5%，该股票的年波动率为4%，求该股票执行价格为20元、期限为1年的欧式看涨期权和看跌期权的价格。

$S=20、r = 5%、\sigma= 4%、K =20、T=1$

代入公式得$d_1=1.27,d_2=1.23$

欧式看涨期权的价格$C_{\mathbb{R}}=S\Phi(d_1)-K\mathrm{e}^{-rT}\Phi(d_2)=20\times0.8980-20\mathrm{e}^{-0.05\times1}\times0.8907=1.0148$

根据欧式期权的平价关系得欧式看跌期权价格$P_\text{欧}=20\times\left(1-0.8907\right)\mathrm{e}^{-0.05\times1}-20\times\left(1-0.8980\right)=0.0394$

B-S定价模型计算期权价值的Python实现

使用Black-Scholes模型计算欧式看涨期权的价格是一个经典的金融计算问题。下面是一个Python程序，它可以根据给定的参数计算欧式看涨期权的价格，并使用多维数组格式输出计算结果。我们还将绘制出计算过程中的每个阶段的值。

Python代码实现：

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73

import numpy as np
import matplotlib.pyplot as plt
from scipy.stats import norm

plt.rcParams['font.sans-serif'] = ['SimHei']  # 用来正常显示中文标签
plt.rcParams['axes.unicode_minus'] = False  # 用来正常显示负号

# Black-Scholes定价模型函数
def black_scholes_call(S, K, T, r, sigma):
    # 计算d1和d2
    d1 = (np.log(S / K) + (r + (sigma ** 2) / 2) * T) / (sigma * np.sqrt(T))
    d2 = d1 - sigma * np.sqrt(T)

    # 计算欧式看涨期权价格
    call_price = S * norm.cdf(d1) - K * np.exp(-r * T) * norm.cdf(d2)
    return call_price, d1, d2


# 参数设定
S = 20  # 当前股票价格
K = 20  # 执行价格
sigma = 0.04  # 波动率
r = 0.05  # 无风险利率
T = 1  # 期权期限（12个月）

# 计算欧式看涨期权价格
call_price, d1, d2 = black_scholes_call(S, K, T, r, sigma)

# 输出计算结果
print(f"欧式看涨期权的价格: {call_price:.4f}")
print(f"d1: {d1:.4f}, d2: {d2:.4f}")

# 为了展示过程，我们可以创建一个树状结构来显示每个阶段的值
# 这里我们只用一个简单的数组来表示阶段
steps = 2
call_prices = np.zeros((steps + 1, steps + 1))

# 填充最后一层的看涨期权价格
for j in range(steps + 1):
    call_prices[j, steps] = max(0, S - K)  # 在最后一步，期权价值为 max(0, S - K)

# 反向递推计算期权价值
for i in range(steps - 1, -1, -1):
    for j in range(i + 1):
        call_prices[j, i] = np.exp(-r * (T / steps)) * (
            (0.5 * call_prices[j, i + 1] + 0.5 * call_prices[j + 1, i + 1])  # 假设等概率
        )

    # 输出每个阶段的值
print("\n每个阶段的看涨期权价值：")
print(call_prices)


# 绘制树状图
def plot_tree(tree, title):
    fig, ax = plt.subplots()
    ax.set_title(title)
    ax.axis('off')

    for i in range(tree.shape[0]):
        for j in range(tree.shape[1]):
            if tree[i, j] != 0:
                ax.text(j, -i, f"{tree[i, j]:.2f}", ha='center', va='center',
                        bbox=dict(boxstyle="round,pad=0.3", edgecolor='black', facecolor='lightgrey'))

    plt.show()


plot_tree(call_prices, "看涨期权价值树")

# 计算并输出看跌期权价格
put_price = K * np.exp(-r * T) - S + call_price
print(f"\n欧式看跌期权的价格: {put_price:.4f}")

代码解释

  1. Black-Scholes定价模型函数：

    • black_scholes_call函数计算给定参数下的欧式看涨期权价格，并返回d1和d2的值。

  2. 参数设定：

    • 根据题目要求设定股票当前价格、执行价格、波动率、无风险利率和期权期限。

  3. 计算欧式看涨期权价格：

    • 调用black_scholes_call函数计算看涨期权价格，并输出结果。

  4. 创建树状结构：

    • 使用一个简单的数组来表示计算过程中的每个阶段的看涨期权价值。

  5. 反向递推计算期权价值：

    • 在树的最后一层填充看涨期权的价值，然后反向计算每个阶段的值。

  6. 绘制树状图：

    • 使用Matplotlib绘制看涨期权价值树。

  7. 计算并输出看跌期权价格：

    • 根据平价关系计算看跌期权价格并输出。

运行上述代码后，会输出欧式看涨期权的价格、d1和d2的值，以及每个阶段的看涨期权价值。最后，还会绘制出看涨期权价值树，并输出看跌期权的价格。

具体输出结果如下所示：

1
2
3
4
5
6
7
8
9

欧式看涨期权的价格: 1.0149
d1: 1.2700, d2: 1.2300

每个阶段的看涨期权价值：
[[0. 0. 0.]
 [0. 0. 0.]
 [0. 0. 0.]]

欧式看跌期权的价格: 0.0395