Physics-Informed Neural Networks for Options Pricing

将 PINN 应用于衍生品的有趣之处不在于 Black-Scholes。Black-Scholes 有闭式解；能够复现它的网络只是健全性检查，而不是成果。真正有趣的是那些没有闭式解、且有限差分也走不通的问题：带有混合偏导 $\partial^2 V / \partial S \partial v$ 的 Heston 双因子 PDE、美国期权的自由边界问题，以及 Merton 的偏积分微分方程，其积分项把定义域中的每个点都与其他所有点耦合起来。

本文讨论如何将这些内容分别写入损失函数。具体包括：让 Black-Scholes PINN 可训练的对数价格残差；混合导数由自动求导直接得到的三输入 Heston 网络；处理提前行权的惩罚法与双网络方案；以及把跳跃积分放入 PDE 残差的 Gauss-Hermite 求积。

本文不是基准测试。下面所有看起来像结果的数字，要么是目标，要么是引用，并且已明确标注。测量工作的范围在文末列出。

PINN 由 Raissi 等人（2019）提出；本博客的纳维-斯托克斯问题已经介绍了其基本机制。在那里，同样的自动求导残差技巧用于寻找流体方程中的奇异性：PDE 成为损失项，自动微分提供网络相对于输入的精确导数，而且完全不需要建立网格。这里唯一改变的是放入损失函数的 PDE。

将 Black-Scholes PDE 作为物理约束

Black-Scholes PDE、终端收益 $\max(S-K,0)$ 及其背后的无套利论证已在Black-Scholes 公式中介绍——本节假定读者已了解这些内容，直接进入网络实际可以训练的形式。

对数价格变换

直接使用 $S$ 会带来问题：定义域为 $[0, \infty)$，而且 PDE 的系数随位置变化。标准变换 $x = \ln(S)$ 可以将其化为常系数形式：

$\frac{\partial V}{\partial t} + \frac{1}{2}\sigma^2 \frac{\partial^2 V}{\partial x^2} + \left(r - \frac{1}{2}\sigma^2\right)\frac{\partial V}{\partial x} - rV = 0$

这是定义在 $x \in (-\infty, \infty)$ 上的对流-扩散-反应方程。变量系数 $S^2$ 和 $S$ 消失了，这对网络很重要：大小随 $S^2$ 缩放的残差会被定义域远端主导，优化器也会在那里耗尽预算。

Black-Scholes 的 PINN 损失

设 $u_\theta(x, t)$ 为网络。在内部采样 $N_r$ 个配点 $(x_i, t_i)$，在边界采样 $N_b$ 个，在终端时刻采样 $N_0$ 个：

$\mathcal{L}_{\text{PDE}} = \frac{1}{N_r}\sum_{i=1}^{N_r}\left[\frac{\partial u_\theta}{\partial t} + \frac{1}{2}\sigma^2 \frac{\partial^2 u_\theta}{\partial x^2} + \left(r - \frac{\sigma^2}{2}\right)\frac{\partial u_\theta}{\partial x} - r u_\theta\right]^2$

$\mathcal{L}_{\text{IC}} = \frac{1}{N_0}\sum_{j=1}^{N_0}\left[u_\theta(x_j, T) - \max(e^{x_j} - K, 0)\right]^2$

$\mathcal{L}_{\text{BC}} = \frac{1}{N_b}\sum_{k=1}^{N_b}\left[u_\theta(x_{\min}, t_k)\right]^2 + \frac{1}{N_b}\sum_{k=1}^{N_b}\left[u_\theta(x_{\max}, t_k) - (e^{x_{\max}} - Ke^{-r(T-t_k)})\right]^2$

每个偏导数都通过 torch.autograd.grad 计算，并设置 create_graph=True，因此反向传播时梯度会穿过导数计算。这一个标志就是实现的全部窍门。

PyTorch 实现

下面的参数更贴近加密资产，而非教科书：$\sigma = 0.7$、$T = 0.08$（大约是 30 天的 BTC 期权），而不是股票交易台常用的 $\sigma = 0.2$、$T = 1.0$。短期限加高波动率会带来最尖锐的收益函数折点，也是 PINN 最难训练的情形——这正是重点。

import torch
import torch.nn as nn
import numpy as np

r = 0.05        # risk-free rate
sigma = 0.7     # volatility
K = 1.0         # strike (moneyness-normalized)
T = 0.08        # ~30 days
x_min, x_max = -1.0, 1.0  # log-price domain (S/K in [0.37, 2.72])

device = torch.device("cuda" if torch.cuda.is_available() else "cpu")


class BSPINN(nn.Module):
    """Physics-Informed Neural Network for Black-Scholes PDE."""

    def __init__(self, hidden_dim=128, num_layers=4):
        super().__init__()
        layers = [nn.Linear(2, hidden_dim), nn.Tanh()]
        for _ in range(num_layers - 1):
            layers += [nn.Linear(hidden_dim, hidden_dim), nn.Tanh()]
        layers.append(nn.Linear(hidden_dim, 1))
        self.net = nn.Sequential(*layers)

    def forward(self, x, t):
        inputs = torch.cat([x, t], dim=1)
        return self.net(inputs)


def compute_pde_residual(model, x, t):
    """Compute Black-Scholes PDE residual using autodiff."""
    x.requires_grad_(True)
    t.requires_grad_(True)
    u = model(x, t)

    grads = torch.autograd.grad(u, [x, t], grad_outputs=torch.ones_like(u),
                                create_graph=True)
    u_x, u_t = grads[0], grads[1]

    u_xx = torch.autograd.grad(u_x, x, grad_outputs=torch.ones_like(u_x),
                               create_graph=True)[0]

    residual = u_t + 0.5 * sigma**2 * u_xx + (r - 0.5 * sigma**2) * u_x - r * u
    return residual


def terminal_condition(x):
    """European call payoff: max(S - K, 0) = max(exp(x) - K, 0)."""
    return torch.relu(torch.exp(x) - K)


def train_pinn(epochs=10000, lr=1e-3, n_interior=5000, n_boundary=500, n_terminal=1000):
    model = BSPINN().to(device)
    optimizer = torch.optim.Adam(model.parameters(), lr=lr)
    scheduler = torch.optim.lr_scheduler.CosineAnnealingLR(optimizer, T_max=epochs)

    for epoch in range(epochs):
        optimizer.zero_grad()

        x_int = (torch.rand(n_interior, 1, device=device)
                 * (x_max - x_min) + x_min)
        t_int = torch.rand(n_interior, 1, device=device) * T

        residual = compute_pde_residual(model, x_int, t_int)
        loss_pde = (residual ** 2).mean()

        x_tc = (torch.rand(n_terminal, 1, device=device)
                * (x_max - x_min) + x_min)
        t_tc = torch.ones(n_terminal, 1, device=device) * T
        u_tc = model(x_tc, t_tc)
        loss_ic = ((u_tc - terminal_condition(x_tc)) ** 2).mean()

        t_bc = torch.rand(n_boundary, 1, device=device) * T

        x_lo = torch.full((n_boundary, 1), x_min, device=device)
        loss_bc_lo = (model(x_lo, t_bc) ** 2).mean()

        x_hi = torch.full((n_boundary, 1), x_max, device=device)
        target_hi = torch.exp(x_hi) - K * torch.exp(-r * (T - t_bc))
        loss_bc_hi = ((model(x_hi, t_bc) - target_hi) ** 2).mean()

        loss = loss_pde + 10.0 * loss_ic + loss_bc_lo + loss_bc_hi

        loss.backward()
        optimizer.step()
        scheduler.step()

        if epoch % 1000 == 0:
            print(f"Epoch {epoch:5d} | PDE: {loss_pde:.2e} | "
                  f"IC: {loss_ic:.2e} | BC: {loss_bc_lo + loss_bc_hi:.2e}")

    return model

下面两个结构性选择值得特别指出：

• 终端条件的权重。 收益函数的权重设为 10 倍，因为它定义了问题。如果不强制执行，网络可以通过处处输出零来轻易满足 PDE——齐次 PDE 有无穷多个解，终端条件负责从中选出一个。
• 每个 epoch 重新采样配点。 每一步都重新抽取点，这相当于对残差进行随机正则化。另一种做法是固定点集，但那会让网络在这些精确坐标上过拟合残差。

扩展到 Heston 随机波动率模型

Black-Scholes 使用单一常数 $\sigma$ 定价，而这正是 GARCH(1,1) 加密资产波动率预测所要否定的假设。Heston 将波动率变成第二个随机因子，即瞬时方差 $v$：

$dS = rS\,dt + \sqrt{v}S\,dW_1$ $dv = \kappa(\theta - v)\,dt + \xi\sqrt{v}\,dW_2$

其中 $\kappa$ 是均值回复速度，$\theta$ 是长期方差，$\xi$ 是波动率的波动率，且 $dW_1 \cdot dW_2 = \rho\,dt$。

定价 PDE 在状态变量上是二维的：

$\frac{\partial V}{\partial t} + \frac{1}{2}vS^2\frac{\partial^2 V}{\partial S^2} + \rho\xi v S\frac{\partial^2 V}{\partial S \partial v} + \frac{1}{2}\xi^2 v\frac{\partial^2 V}{\partial v^2} + rS\frac{\partial V}{\partial S} + \kappa(\theta - v)\frac{\partial V}{\partial v} - rV = 0$

这正是无网格方法开始显出吸引力的地方。有限差分需要在 $(S, v, t)$ 上建立网格——典型的 $200 \times 100 \times 500$ 网格就有 $10^7$ 个节点。再加入随机利率等第三个随机因子，网格就变得不可行。蒙特卡洛在维度方面扩展性更好，但收敛很慢，尤其是对希腊字母而言。

Heston 的 PINN 架构

网络接收三个输入 $(x, v, t)$，其中 $x = \ln S$。混合偏导 $\partial^2 u / \partial x \partial v$——让 ADI 方案变得棘手的那一项——只需再调用一次 autograd.grad：

class HestonPINN(nn.Module):
    def __init__(self, hidden_dim=256, num_layers=5):
        super().__init__()
        layers = [nn.Linear(3, hidden_dim), nn.Tanh()]
        for _ in range(num_layers - 1):
            layers += [nn.Linear(hidden_dim, hidden_dim), nn.Tanh()]
        layers.append(nn.Linear(hidden_dim, 1))
        self.net = nn.Sequential(*layers)

    def forward(self, x, v, t):
        return self.net(torch.cat([x, v, t], dim=1))


def heston_pde_residual(model, x, v, t, kappa, theta, xi, rho, r):
    x.requires_grad_(True)
    v.requires_grad_(True)
    t.requires_grad_(True)
    u = model(x, v, t)

    u_x, u_v, u_t = torch.autograd.grad(
        u, [x, v, t], torch.ones_like(u), create_graph=True
    )
    u_xx = torch.autograd.grad(u_x, x, torch.ones_like(u_x), create_graph=True)[0]
    u_vv = torch.autograd.grad(u_v, v, torch.ones_like(u_v), create_graph=True)[0]
    u_xv = torch.autograd.grad(u_x, v, torch.ones_like(u_x), create_graph=True)[0]

    residual = (
        u_t
        + 0.5 * v * u_xx
        + rho * xi * v * u_xv
        + 0.5 * xi**2 * v * u_vv
        + (r - 0.5 * v) * u_x
        + kappa * (theta - v) * u_v
        - r * u
    )
    return residual

注意，u_xv 是对 u_x 关于 v 求导得到的，复用了第一次调用建立的计算图。混合偏导的对称性意味着，对 u_v 关于 x 求导应得到相同的张量；但在 float32 中它不会完全相同，而这个差值可以廉价地诊断计算图是否正常工作。

美国期权与自由边界问题

美国期权增加了提前行权约束：价值绝不能低于内在价值。这会把 PDE 变成自由边界问题，等价地说是线性互补问题（LCP）：

$\frac{\partial V}{\partial t} + \mathcal{L}V \leq 0, \quad V \geq \Phi(S), \quad \left(\frac{\partial V}{\partial t} + \mathcal{L}V\right)(V - \Phi(S)) = 0$

其中 $\mathcal{L}$ 是 Black-Scholes 算子，$\Phi(S)$ 是收益函数。可以用两种方式将其写入损失。

惩罚法

用平滑惩罚替代互补约束：

$\frac{\partial V}{\partial t} + \mathcal{L}V + \rho_p \cdot \max(\Phi(S) - V, 0) = 0$

其中 $\rho_p$ 很大（通常为 $10^4$ 到 $10^6$）。当 $V$ 低于内在价值时，惩罚会迫使它回升，PINN 损失变为：

$\mathcal{L}_{\text{PDE}}^{\text{American}} = \frac{1}{N_r}\sum_i \left[\frac{\partial u_\theta}{\partial t} + \mathcal{L}u_\theta + \rho_p \cdot \max(\Phi - u_\theta, 0)\right]^2$

无需改变架构，只需修改残差。代价是增加一个超参数，并引入糟糕的条件数权衡：太小则约束会被违反，太大则损失地形会被惩罚项支配。

直接自由边界方法

联合训练两个网络：一个用于价格 $u_\theta(S, t)$，另一个用于最优行权边界 $S^*_\phi(t)$。损失在继续持有区域包含 PDE，在边界包含光滑粘着条件，在行权区域包含收益函数。边界成为一等输出，而这正是对美国期权组合进行对冲时真正需要的东西。

使用 PINN 的跳跃扩散模型

Merton 模型在几何布朗运动中加入了泊松跳跃：

$dS = (r - \lambda \bar{k})S\,dt + \sigma S\,dW + S\,dJ$

其中 $J$ 是强度为 $\lambda$、跳跃幅度服从对数正态分布的复合泊松过程。定价变成偏积分微分方程（PIDE）：

$\frac{\partial V}{\partial t} + \frac{1}{2}\sigma^2 S^2 \frac{\partial^2 V}{\partial S^2} + (r - \lambda\bar{k})S\frac{\partial V}{\partial S} - (r + \lambda)V + \lambda \int_0^\infty V(Sy, t) f(y)\,dy = 0$

其中 $f(y)$ 是跳跃乘数的密度。

积分正是有限差分难以处理的部分——它把定义域中的每个点与其他所有点耦合，破坏了求解器所依赖的带状结构。PINN 没有这种结构可供破坏。积分只是残差中的另一项，在每个配点处通过求积计算；由于网络在所有位置都有定义，$V(Sy, t)$ 是一次免费的前向传播，而不是插值：

def jump_integral(model, x, t, lam, mu_j, sigma_j, n_quad=32):
    """Approximate jump integral using Gauss-Hermite quadrature."""
    nodes, weights = np.polynomial.hermite.hermgauss(n_quad)
    nodes = torch.tensor(nodes, dtype=torch.float32, device=x.device)
    weights = torch.tensor(weights, dtype=torch.float32, device=x.device)

    y_nodes = mu_j + sigma_j * np.sqrt(2) * nodes
    integral = torch.zeros_like(x)

    for i in range(n_quad):
        x_shifted = x + y_nodes[i]
        v_shifted = model(x_shifted, t)
        integral += weights[i] * v_shifted

    integral *= 1.0 / np.sqrt(np.pi)
    return integral

PIDE 残差为：

$\text{Residual} = \frac{\partial u}{\partial t} + \frac{1}{2}\sigma^2 u_{xx} + (r - \lambda\bar{k} - \frac{\sigma^2}{2})u_x - (r + \lambda)u + \lambda \cdot I[u]$

其中 $I[u]$ 是求积近似。循环会使每个训练步骤额外进行 n_quad 次前向传播，所有这些传播都会进入自动求导图——跳跃的真正代价是内存，而不是数学运算。

与传统方法的比较

结构性差异是真实存在的，无需基准测试也可以说明：

通常应该出现在这里的性能行——训练时间、推理延迟和准确率——被有意省略，因为测量它们是待完成的工作，而不是表格中的一项。

PINN 可能胜出的地方

实时重新定价。 训练完成后，评估只是对一个批次执行前向传播，因此整个组合可以在一次内核启动中完成重新定价，而不是每组参数求解一次。在实际组合规模下，这是否胜过经过良好调优的 Crank-Nicolson 求解器，仍是一个经验问题，目前尚未测量。

高维模型。 随机波动率、随机利率再加上跳跃会达到 4 个及以上维度，此时有限差分实际上已经失效。PINN 随维度增加会逐步退化，但仍受训练难度限制。

连续希腊字母。 网络平滑且可微，因此 Delta、Gamma、Theta 和 Vega 与 PDE 残差使用同一套自动求导机制得到——无需扰动并重估，也没有有限差分噪声。这是本文最强的主张，也是最需要用实测 Gamma 曲面支撑的主张。

参数化解。 将模型参数（$\sigma$、$\kappa$、$\theta$）作为网络输入，可以让一个 PINN 覆盖一族模型，而不是只覆盖一次校准。

PINN 面临困难的地方

训练成本。 对于单一参数集下的一个期权，有限差分求解在 PINN 完成前一千个 epoch 之前就已经结束了。

没有误差界。 采用 Richardson 外推的有限差分可以凭已知收敛阶达到机器精度。PINN 报告的是损失值，而不是误差界。不确定性感知变体（Bai 等人，2025）会附加置信区间，但这个领域还很年轻。

优化困难。 损失地形高度非凸，而 PDE、边界项与终端项之间的权重是一个调参问题。典型的失败模式是：网络把 PDE 残差降到接近零，却完全忽略边界条件——这对错误的问题来说是一个完全有效的解。

可复现性。 不同随机种子、配点分布和优化器设置可能得到有实质差异的解。集成方法有所帮助，但也会成倍增加成本。

后两点是本文最值得转化为图表的部分，因为任何重新实现这些方法的人都会遇到这些失败模式。

仍需测量的内容

坦率地说，本文目前的状态是：公式正确，代码也能运行，但尚未在本交易台的硬件或数据上进行基准测试。要让它从推导变成结果，还需要完成以下测量：

1. 在 $(S, t)$ 网格上与闭式 Black-Scholes 比较 sup-norm 和 RMSE，每个种子运行一次，共五个种子。通常流传的目标是达到小数点后 4 位以上的一致；关键在于用 $\sigma = 0.7$、$T = 0.08$ 验证这一点，并公布失败时对应的种子。
2. 测量 Delta 和 Gamma 误差，而不仅是价格误差。 如果网络价格匹配到四位小数，但 $\Gamma$ 噪声很大，那么它对对冲毫无用处，因此 Gamma 是验收标准。
3. 测量 10,000 个期权组合的实际训练耗时和单期权推理延迟，并在同一 GPU 上与相同问题的 Crank-Nicolson 求解比较。
4. 有意复现失败模式。 降低边界损失的权重，直到网络满足 PDE 却错过边界；运行五个种子并绘制差异。两项实验都很容易完成，也比再绘制一个看似正确的价格曲面更有价值。
5. 拟合真实的 Deribit BTC 报价，或者至少保留上面的加密资产现实参数，不要退回到 $\sigma = 0.2$、$T = 1.0$。
6. 把架构和优化器选择作为实验发现，而不是建议。 更宽与更深的网络、tanh 与 ReLU（ReLU 不连续的二阶导数应当明显破坏残差）、$\lambda_{\text{IC}}$ 扫描，以及 Adam 接 L-BFGS 与单独使用 Adam 的比较，都是一行代码即可开展的实验。在运行之前，它们都只是从文献中重复的经验说法；本文拒绝把它们重复成建议。

即使没有测量，仍有两个结构性主张成立，因为它们是公式的性质，而不是某次运行的性质：使用对数价格坐标（PDE 变为常系数形式，这是代数事实），并提高终端条件相对于 PDE 项的权重（齐次 PDE 允许零解，这是问题本身的事实）。

还有哪些方向

以下方向值得了解，但本文都没有测试：

• 残差自适应配点采样——在残差较大的地方放置点，例如 Black-Scholes 的行权价附近或 Heston 的 Feller 边界附近，而不是均匀采样。实现很短：

def adaptive_resample(model, x_pool, t_pool, n_select):
    """Select collocation points with highest PDE residual."""
    with torch.no_grad():
        residuals = compute_pde_residual(model, x_pool, t_pool).abs()
    probs = residuals.squeeze() / residuals.sum()
    indices = torch.multinomial(probs, n_select, replacement=False)
    return x_pool[indices], t_pool[indices]

• 跨行权价和到期日的迁移学习——从相邻的 $(K, T)$ 微调，而不是从头训练，以维护一个覆盖整条期权链的模型库。
• 物理信息极限学习机——冻结隐藏层权重，只训练输出层，将训练简化为一次线性求解。表达能力较弱，但 Black-Scholes 的维度足够低，可能并不重要。
• 算子学习（DeepONet、FNO）——学习解算子而非具体解，将 $(\sigma(\cdot), r(\cdot), \text{payoff}(\cdot)) \to V(\cdot,\cdot)$，这样新的收益结构无需重新训练。参见 DeepSVM。

结论

PINN 不会取代有限差分或蒙特卡洛。对于单一参数集下的单个低维期权，有限差分占优，而且差距并不小。PINN 的适用场景很窄也很明确：网格方法失效的高维模型；在整个组合中重复使用的参数化解；以及与价格由同一次自动微分传播得到的希腊字母。

本文交付的是翻译层：Heston 混合偏导、美国期权自由边界和 Merton 跳跃积分，分别如何成为损失函数中的一项。本文尚未交付的是证据——证明这些网络足够准确，可以用于对冲。这是下一轮工作；在它完成之前，应把上文全部视为推导，而不是建议。

参考文献与延伸阅读

• Raissi, M., Perdikaris, P., Karniadakis, G.E. (2019). 物理信息神经网络：用于求解涉及非线性偏微分方程的正问题和逆问题的深度学习框架。计算物理学杂志，378，686-707。
• Dhiman, A., Kaur, D. (2023)。用于期权定价的物理信息神经网络。arXiv 预印本。
• Salvador, B. 等人（2023）。通过物理信息神经网络进行美国期权定价的无网格方法。边界元工程分析。
• Bai, G. 等人（2025）。Black-Scholes 方程的不确定性感知物理信息神经网络解。arXiv 预印本。
• Chen, Y. 等人（2025）。数据稀缺条件下用于美国期权定价的随机跳跃扩散过程信息神经网络。应用软计算。
• Benth, F.E. 等人（2025）。DeepSVM：利用物理信息深度算子网络学习随机波动率模型。arXiv 预印本。
• He, Y. 等人（2024）。金融信息神经网络：学习期权定价的几何结构。arXiv 预印本。
• MathWorks：用于期权定价的物理信息神经网络（PINN）。MATLAB 金融博客，2025 年。
• GitHub：BlackScholesPINN（PyTorch 实现）。
• Raissi PINN 的 GitHub 仓库。