基於偏微分方程的金融建模的傅立葉神經算子

到目前為止，本部落格上的每個神經網路都近似於一個「函數」：輸入特徵，輸出數字。傅立葉神經算符近似於算子－無限維函數空間之間的映射，其中輸入是整個波動率表面，輸出是整個價格表面。這是一個不同的對象，它需要不同的機制，而機制是本文的重點：應用於最低傅立葉模式的可學習複值內核，透過 FFT 往返進行評估 $O(n \log n)$。

期權定價是金融領域的重點。 Black-Scholes、Heston、局部波動性——所有偏微分方程，今天都一次解決一組參數。操作員立即學習整個參數系列，並且產生的前向傳遞是單一批次的 GPU 內核，而不是時間推進循環。

這就是承諾。本文的誠實版本將機制與性能聲明區分開來，這些機制是可靠的，並且可以從下面的代碼中重現，在 FNO 文獻中，這些性能聲明是根據本系列中沒有人會接受未經檢查的基線進行報告的。機械是第一位的；測量議程位於最後，標記為未運行。

從函數逼近到算子學習

經典神經網路近似函數：給定輸入 $x \in \mathbb{R}^n$，它們產生一個輸出 $y \in \mathbb{R}^m$。這是強大的，但當感興趣的物件本身就是函數時，它從根本上受到限制。在金融偏微分方程求解中，輸入不是單一數字，而是描述初始/邊界條件、波動率表面或期限結構的函數。輸出是另一個函數：價格表面 $(S, t)$ 空間。

算子學習將問題提升到無限維空間。而不是學習 $f: \mathbb{R}^n \to \mathbb{R}^m$，我們學習一個運算符：

$\mathcal{G}: \mathcal{A} \to \mathcal{U}$

在哪裡 $\mathcal{A}$ 和 $\mathcal{U}$ 是巴拿赫函數空間。對於期權定價， $\mathcal{A}$ 可能是波動面的空間 $\sigma(S,t)$ 和 $\mathcal{U}$ 對應價格面的空間 $V(S,t)$。

兩種架構在操作員學習領域中佔據主導地位：

1. DeepONet (Lu et al., 2021)：使用分支網路對輸入函數進行編碼，並使用主幹網路對查詢位置進行編碼。輸出是它們的內積。以 Chen 和 Chen (1995) 的算符萬能逼近定理為基礎。

2. 傅立葉神經算符（Li et al., 2021）：參數化傅立葉空間中的積分核，使用 FFT 進行高效的全局卷積。結構分辨率不變。

兩者都是連續算子的通用逼近器，但 FNO 對於 PDE 問題具有結構優勢：它的頻譜偏差自然地捕捉了 PDE 解的平滑、全局結構。它對於期權收益也有一個結構性的“缺點”，我們稍後會討論這一點——截斷的傅裡葉基礎和罷工的扭結並不是天然的盟友。

FNO 架構詳細信息

Li 等人提出的傅立葉神經算符。在 ICLR 2021 上，建立在一個簡單但強大的觀察基礎上：許多偏微分方程的格林函數（積分核）在傅立葉空間中具有緊湊的表示。而不是在物理空間中學習核心——這需要 $O(n^2)$ 參數為 $n$ 網格點－FNO 在頻率空間中僅用最低的值來學習它 $k_{\max}$ 模式，將複雜度降低到 $O(n \log n)$ 透過FFT。

迭代架構

FNO 包括：

1. 提升層 $P$：將輸入從原始通道維度投影到更高維度的潛在表示的逐點線性映射： $v_0(x) = P(a(x))$。

2. 傅立葉層（重複 $L$ 次）：每層適用：

$v_{l+1}(x) = \sigma\left(W_l \, v_l(x) + \mathcal{K}_l(v_l)(x)\right)$

在哪裡 $W_l$ 是局部線性變換（逐點 $1 \times 1$ 卷積）和 $\mathcal{K}_l$ 是透過 FFT 實現的全域積分運算子：

$\mathcal{K}_l(v_l)(x) = \mathcal{F}^{-1}\left(R_l \cdot \mathcal{F}(v_l)\right)(x)$

這裡 $\mathcal{F}$ 表示 FFT， $R_l$ 是一個可學習的複值權重張量，應用於最低 $k_{\max}$ 傅立葉模式，以及 $\sigma$ 是逐點非線性活化（通常是 GELU）。

3. 投影層 $Q$：將潛在表示映射回輸出維度： $u(x) = Q(v_L(x))$。

為什麼選擇傅立葉空間？

譜卷積 $R_l \cdot \mathcal{F}(v_l)$ 是頻域中的乘法，相當於物理空間中的全域卷積 - 但計算為 $O(n \log n)$ 而不是 $O(n^2)$。這不僅僅是一個效率技巧。 PDE 解通常是平滑的並且以低頻成分為主。透過截斷到 $k_{\max}$ 模式中，FNO 充當可學習的低通濾波器，自然地規範解決方案並避免高頻偽影。

至關重要的是，FNO 據稱具有離散化不變：一旦在一定大小的網格上進行訓練 $n$，可以在任何解析度上進行評估 $m \neq n$ 透過簡單地調整 FFT 大小和零填充或截斷頻譜權重。這種零樣本超解析度屬性在神經 PDE 求解器中是獨一無二的 - 這是本文中第一個值得測量而不是引用的主張。請參閱下面的測量議程。

我們正在學習算子的偏微分方程

Black-Scholes PDE — 逐項推導、剖析，並在 The Black-Scholes Formula 中給出其封閉式看漲/看跌解決方案 — 是運算符目標：

$\frac{\partial V}{\partial t} + \frac{1}{2}\sigma^2 S^2 \frac{\partial^2 V}{\partial S^2} + rS\frac{\partial V}{\partial S} - rV = 0$

接下來的一切都將其視為一個具有已知答案的黑盒子。這個已知的答案正是為什麼它是正確的測試案例：可以根據有限差分輸出訓練的操作員進行評分 norm.cdf 準確的價格，文獻中幾乎沒有 FNO 基準可以做到。

FNO 配方

我們將問題重新定義為操作員學習。定義：

• 輸入功能 $a(S, t)$：對 PDE 參數進行編碼。這可以包括波動率表面 $\sigma(S, t)$、支付函數和無風險利率作為通道堆疊在 $(S, t)$ 網格。
• 輸出功能 $u(S, t) = V(S, t)$：選擇權價格面。

FNO 學習 $\mathcal{G}_\theta: a \mapsto u$ 從資料集 $(a^{(i)}, u^{(i)})$ 由傳統求解器產生的對。訓練後，任何新參數配置的推理都是一次前向傳遞。

訓練資料生成

import numpy as np
from scipy.stats import norm

def black_scholes_fd(sigma, r, K, T, S_max=300, N_S=256, N_t=256):
    """Solve Black-Scholes PDE via explicit finite differences.

    NOTE: this is an interpreted double loop — the *worst* CPU baseline,
    exactly the kind called out in /en/blog/post/when-gpu-pays-off-sweep-roofline.
    It is fine for generating training data offline. It is NOT the baseline
    any speedup claim should be measured against; vectorize the inner loop
    over i (or use scipy sparse + implicit stepping) before timing anything.
    """
    dS = S_max / N_S
    dt = T / N_t
    S = np.linspace(0, S_max, N_S + 1)

    V = np.maximum(S - K, 0).astype(np.float64)

    for j in range(N_t):
        V_new = V.copy()
        for i in range(1, N_S):
            delta = (V[i+1] - V[i-1]) / (2 * dS)
            gamma = (V[i+1] - 2*V[i] + V[i-1]) / (dS**2)
            V_new[i] = V[i] + dt * (
                0.5 * sigma**2 * S[i]**2 * gamma
                + r * S[i] * delta
                - r * V[i]
            )
        V_new[0] = 0
        V_new[N_S] = S_max - K * np.exp(-r * (T - (j+1)*dt))
        V = V_new

    return S, V

為了進行訓練，我們對數千種參數配置進行了採樣——不同的 $\sigma \in [0.05, 0.80]$, $r \in [0.01, 0.10]$, $K \in [50, 150]$, $T \in [0.1, 2.0]$ - 並用有限差分法解每個問題。 FNO 可以從中學習輸入輸出對的結果資料集。

擴大規模：赫斯頓隨機波動率模型

持續波動性是已知錯誤的假設，而它失敗的原因——微笑、肥尾——是布萊克-斯科爾斯公式「嚴酷的現實」部分的主題。 Heston 透過將變異數作為第二個狀態變數來修復它：

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

和 $\text{Corr}(dW_1, dW_2) = \rho$。選擇權價格對應的 PDE $V(S, v, t)$ 在空間中是二維的：

$\frac{\partial V}{\partial t} + \frac{1}{2}vS^2\frac{\partial^2 V}{\partial S^2} + \rho\xi vS\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)$ 網格尺度為 $O(N_S \times N_v \times N_t)$，交叉導數項 $\partial^2 V / \partial S \partial v$ 使離散化變得複雜，並且每個新的參數集 $(\kappa, \theta, \xi, \rho, r)$ 再次支付全部費用。操作員在培訓時支付一次。 Heston PDE 的 2D 空間結構也直接對應到傅立葉層中的 2D FFT，因此下面的架構透過維度變更而不是重新設計進行概括。

用於期權定價的 FNO：PyTorch 實現

以下是一個完整的、獨立的 FNO 實現，用於學習 Black-Scholes 算子。該架構遵循 Li 等人的觀點。 （2021）並針對金融環境進行了調整。

import torch
import torch.nn as nn
import torch.nn.functional as F
from torch.fft import rfft, irfft

class SpectralConv1d(nn.Module):
    """1D Fourier layer: spectral convolution via FFT."""

    def __init__(self, in_channels: int, out_channels: int, modes: int):
        super().__init__()
        self.in_channels = in_channels
        self.out_channels = out_channels
        self.modes = modes  # Number of Fourier modes to keep

        scale = 1.0 / (in_channels * out_channels)
        self.weights = nn.Parameter(
            scale * torch.randn(in_channels, out_channels, modes, dtype=torch.cfloat)
        )

    def forward(self, x: torch.Tensor) -> torch.Tensor:
        batch_size = x.shape[0]

        x_ft = rfft(x, dim=-1)

        out_ft = torch.zeros(
            batch_size, self.out_channels, x_ft.size(-1),
            dtype=torch.cfloat, device=x.device
        )
        out_ft[:, :, :self.modes] = torch.einsum(
            "bix,iox->box", x_ft[:, :, :self.modes], self.weights
        )

        return irfft(out_ft, n=x.size(-1), dim=-1)


class FNOBlock(nn.Module):
    """Single Fourier Neural Operator block."""

    def __init__(self, channels: int, modes: int):
        super().__init__()
        self.spectral_conv = SpectralConv1d(channels, channels, modes)
        self.pointwise = nn.Conv1d(channels, channels, kernel_size=1)
        self.norm = nn.InstanceNorm1d(channels)

    def forward(self, x: torch.Tensor) -> torch.Tensor:
        return F.gelu(self.norm(self.spectral_conv(x) + self.pointwise(x)))


class FNO1d(nn.Module):
    """
    Fourier Neural Operator for 1D PDE problems.

    Learns the mapping: PDE parameters -> solution function
    """

    def __init__(
        self,
        in_channels: int = 3,    # e.g., sigma(S), payoff(S), grid(S)
        out_channels: int = 1,   # V(S)
        hidden_channels: int = 64,
        modes: int = 32,
        num_layers: int = 4,
    ):
        super().__init__()
        self.lift = nn.Linear(in_channels, hidden_channels)
        self.blocks = nn.ModuleList(
            [FNOBlock(hidden_channels, modes) for _ in range(num_layers)]
        )
        self.proj = nn.Sequential(
            nn.Linear(hidden_channels, 128),
            nn.GELU(),
            nn.Linear(128, out_channels),
        )

    def forward(self, x: torch.Tensor) -> torch.Tensor:
        x = self.lift(x)                    # -> (batch, spatial, hidden)
        x = x.permute(0, 2, 1)              # -> (batch, hidden, spatial)

        for block in self.blocks:
            x = block(x)

        x = x.permute(0, 2, 1)              # -> (batch, spatial, hidden)
        return self.proj(x)                  # -> (batch, spatial, out_channels)

訓練循環

import torch.optim as optim
from torch.utils.data import DataLoader, TensorDataset

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

    N_samples = 5000
    N_S = 256
    S_max = 300.0
    S_grid = np.linspace(0, S_max, N_S + 1)

    inputs, targets = [], []
    for _ in range(N_samples):
        sigma = np.random.uniform(0.05, 0.80)
        r = np.random.uniform(0.01, 0.10)
        K = np.random.uniform(50, 150)
        T = np.random.uniform(0.1, 2.0)

        _, V = black_scholes_fd(sigma, r, K, T, S_max=S_max, N_S=N_S)

        sigma_field = np.full(N_S + 1, sigma)
        payoff = np.maximum(S_grid - K, 0)
        grid_norm = S_grid / S_max

        inp = np.stack([sigma_field, payoff, grid_norm], axis=-1)
        inputs.append(inp)
        targets.append(V[:, None])

    X = torch.tensor(np.array(inputs), dtype=torch.float32)
    Y = torch.tensor(np.array(targets), dtype=torch.float32)

    dataset = TensorDataset(X, Y)
    loader = DataLoader(dataset, batch_size=64, shuffle=True)

    model = FNO1d(in_channels=3, out_channels=1, hidden_channels=64, modes=32).to(device)
    optimizer = optim.AdamW(model.parameters(), lr=1e-3, weight_decay=1e-4)
    scheduler = optim.lr_scheduler.CosineAnnealingLR(optimizer, T_max=200)

    for epoch in range(200):
        model.train()
        total_loss = 0.0
        for batch_x, batch_y in loader:
            batch_x, batch_y = batch_x.to(device), batch_y.to(device)

            pred = model(batch_x)
            loss = torch.mean(
                torch.norm(pred - batch_y, dim=1)
                / torch.norm(batch_y, dim=1).clamp(min=1e-8)
            )

            optimizer.zero_grad()
            loss.backward()
            optimizer.step()
            total_loss += loss.item()

        scheduler.step()
        if (epoch + 1) % 20 == 0:
            avg = total_loss / len(loader)
            print(f"Epoch {epoch+1:3d} | Relative L2 Loss: {avg:.6f}")

    return model

推理：即時定價

@torch.no_grad()
def price_option(model, sigma, K, S_grid, device="cuda"):
    """
    Price a European call for given sigma and strike.
    Returns prices for all S in S_grid — single forward pass.
    """
    S_max = S_grid[-1]
    payoff = np.maximum(S_grid - K, 0)
    grid_norm = S_grid / S_max
    sigma_field = np.full_like(S_grid, sigma)

    inp = np.stack([sigma_field, payoff, grid_norm], axis=-1)
    x = torch.tensor(inp, dtype=torch.float32).unsqueeze(0).to(device)

    pred = model(x)
    return pred.squeeze().cpu().numpy()

FNO 與 PINN：實際比較

物理資訊神經網路和傅立葉神經算子代表了使用神經網路求解偏微分方程的根本不同的哲學。了解他們的權衡是關心算子學習的實際原因。

PINN：每個實例優化

PINN 將 PDE 殘差直接放入損失中 - 納維-斯托克斯問題 涵蓋了自動差分機制 physics_loss 實現，以及 DeepMind 奇點搜尋結果。這裡唯一重要的屬性是結構性的：**PINN 根據參數集進行訓練。 ** 更改 $\sigma$, $r$, $K$ 或者 $T$ 然後你從頭開始再次優化。

優點：無需標記資料。直接強制執行 PDE 結構。適用於您可以寫下的任何偏微分方程式。

弱點：必須針對每個新參數集重新訓練 $(\sigma, r, K, T)$。訓練涉及平衡多個損失項（PDE 殘差、邊界條件、初始條件），這通常會導致最佳化病態。收斂速度可能很慢——通常每個問題實例需要 10,000–100,000 個梯度步。在損失景觀變得高度非凸的多尺度和混沌系統上失敗。

FNO：攤銷算子學習

FNO 從資料中學習解算子。它需要由經典求解器產生的訓練資料集，但一旦訓練完畢，它就會泛化到整個參數空間。

優勢：已發布的基準中的亞毫秒級推理。無需重新訓練即可推廣到看不見的參數。解析度不變－以低解析度訓練，以高解析度評估。透過譜偏差自然地處理平滑的 PDE 解決方案。

弱點：需要經典解算器的訓練資料（真正新穎的偏微分方程的先有雞還是先有蛋的問題）。近似誤差有界但非零。與偏微分方程約束方法相比，其可解釋性較差。有助於平滑解決方案的光譜偏差是回報扭結的一種負擔。

頭對頭比較

下表是文獻報導的，此處未測量 - 準確度和加速比行尤其來自 Li 等人。 （2021）以及流動基準的後續工作，而不是來自我們硬體上的選擇權定價。將結構行（所需資料、泛化、解析度不變性）讀取為可靠行。

混合體：基於物理的神經算子 (PINO)

PINO（Li et al., 2024）結合了這兩種方法。它使用 FNO 架構，但透過 PDE 殘差項增強了資料驅動的損失：

$\mathcal{L}_{\text{PINO}} = \mathcal{L}_{\text{data}} + \lambda \, \mathcal{L}_{\text{PDE}}$

分解是有用的部分。 $\mathcal{L}_{\text{data}}$ 將運算子錨定到解算器輸出（無論您擁有什麼）； $\lambda \mathcal{L}_{\text{PDE}}$ 在您不這樣做的任何地方對其進行約束，包括您從未採樣過的參數空間區域。對於選擇權定價，第二項由於金融特定的原因而具有吸引力：PDE 殘差是一個「硬」約束，您也可以在推理時評估作為自檢，這是下面殘差監控回退的基礎。

生產部署的實際注意事項

其中通用的一半——推理延遲預算、建立資料管道、監控漂移、定期再訓練——已經在DeepLOB：限價訂單簿上的深度學習的生產部分的交易系統中的神經模型中涵蓋，並且它不改變地適用。以下內容僅針對操作員。

資料管道：對參數空間進行取樣

產生訓練資料是主要瓶頸，與市場資料模型不同，你可以選擇自己的分佈——這意味著你可能會以一種在損失中不可見的方式出錯。對於具有 4 個參數的 Black-Scholes 算子，5,000–10,000 個樣本就足夠了。對於具有 5 個參數加上 2D 空間域的 Heston，典型情況是 20,000–50,000 個樣本。使用自適應採樣：將樣本集中在解決方案快速變化的參數區域（接近貨幣、短期、高波動性），因為盒子的均勻採樣將大部分預算花費在深度 ITM 和深度 OTM 區域，在這些區域中，算子幾乎是線性的，並且可以從很少的示例中很好地學習。

架構調整

• 模式 ($k_{\max}$): 開始於 $N/4$ 在哪裡 $N$ 是空間網格大小。為了 $N=256$，使用 32–64 模式。太少的模式會在走向邊界附近失去細節；太多對雜訊的過度擬合。
• 層：4 個傅立葉層是標準配置。更深的網路 (6-8) 有助於解決像 Heston 這樣的 2D 問題，但會增加記憶體。
• 隱藏通道：1D Black-Scholes 為 64，2D Heston 為 128。隨著問題的複雜性而擴展。

精確度：fp32 問題

SpectralConv1d 分配 torch.cfloat — 單精度複數 — 每個 FFT 往返都以該精度運作。本部落格已經在 GPU 精度陷阱 中看到了 fp32 金融管道回傳無聲垃圾，其中數學上正確的前綴和公式在 fp32 量級上發生了災難性的損失。這裡的類似問題是直接的：在 $S \approx 100$ 以美分報價，FP32 光譜往返是否成立 $10^{-2}$ 絕對值，還是 FFT 的中間幅度成長會吃掉最後的有效數字？

錯誤控制

對於生產期權定價，您需要可以防禦的誤差界限。

1. 校準的不確定性：集合標準差不是覆蓋範圍保證，並且本博客有適當的機制來做到這一點 - 在保留的參數網格上分割保形，對於不可交換的情況使用 ACI/DtACI，在風險意識頭寸規模調整的保形預測中。將 FNO 包裹在分裂保形中 $(\sigma, r, K, T)$ 網格給出了價格的無分佈區間。
2. 殘差監控：計算 FNO 預測的 PDE 殘差作為事後檢查。如果 $\|\text{residual}\| > \epsilon$，回到經典求解器。這在推理時是免費的——殘差是您已有的數組上的有限差分模板。
3. 主動學習：將高不確定性輸入路由到經典求解器，將結果加入訓練集中，並定期重新訓練。 (1) 中的保形間隔寬度是自然路由訊號。

衡量議程

這就是決定上面的架構是否值得部署的部分，目前還沒有完成。它被列在這裡而不是被埋沒，因為另一種選擇——聲稱標題加速——正是這個部落格要避免的寄存器。

**1.加速比是一條曲線，而不是一個數字。 ** 當 GPU 發揮作用時 建立了形狀： $S(B) = aB/(O + bB)$，從開銷主導上升 $B=1$ 到計算密集型平台，它顯示標題 167 倍分解為 27 倍演算法乘以 6.2 倍硬體。 FNO 測量必須遵循此模板：掛鐘前向傳播 $B \in \{1, 8, 64, 512\}$ 並報告整個曲線。至關重要的是，基準必須是「向量化、多核心」有限差分求解器—— black_scholes_fd 上面是一個解釋的雙循環，即文章所命名的確切「最差 CPU 實作」基線，將批次 GPU 運算子與它進行比較將產生一個毫無意義的數字。

**2.針對封閉形式的準確性。 ** 這是 Black-Scholes 幾乎免費進行的實驗，而流體力學基準根本無法做到：訓練 FD 產生的數據，然後根據精確值進行評分 norm.cdf 各地的價格 $(\sigma, r, K, T)$ 盒子。檢舉親屬 $L^2$，並報告錯誤分佈 - 特別是在接近罷工和接近到期時，其中解決方案最不平滑，並且截斷的頻譜基礎應該最困難。

**3.無套利違規。 ** 學習算符沒有結構性原因來遵守價格表面必須滿足的形狀限制：單調性 $K$，凸性在 $K$， 和 $V \geq \max(S-K, 0)$。測量參數框中的違規率將本文自己的開放性問題（我們能否保證學習運算符中的無套利條件？）從揮手變成了數字。

**4.離散化不變性，經過測試而不是斷言。 ** 訓練 $N_S = 128$，評估於 $N_S = 512$，報告錯誤。預期的故障模式已命名且具體：吉布斯扭結振鈴 $\max(S-K, 0)$。截斷傅立葉基重建具有不連續一階導數的函數，並在其周圍振盪，而零樣本超解析度會暴露訓練解析度從未見過的模式，從而使情況變得更糟而不是更好。如果超解析度在接近罷工時降級，那麼這種負面結果比它所取代的行銷宣傳更有價值——FNO 文獻中沒有人以回報扭結來定價選擇權。

如果實驗 1-4 無法運行，本文不應發布。沒有它們，剩下的是對其他人 ICLR 論文的精心闡述。

超越普通選項

假設上述議程在與測量的接觸中仍然存在，FNO 框架自然會擴展到更複雜的儀器：

• 美式選擇權：新增早期行使邊界作為額外的輸出通道。 FNO 同時學習價格面和最佳執行邊界。
• 屏障選項：將屏障等級編碼為輸入通道。請注意，障礙是第二個不連續性，測量議程中的吉布斯關注更加適用，而不是更少。
• 多元資產籃子：使用 2D 或 3D FNO 作為 2-3 個底層證券的籃子選擇權。維數災難沒有基於網格的求解器那麼嚴重，因為 FNO 運行在固定數量的模式上。
• 局部波動性：輸入完整的 Dupire 局部波動率表面 $\sigma_{\text{loc}}(S,t)$ 作為空間函數。這是算子學習最自然的用例－輸入是一個函數，而不是一個標量參數。

結論

傅立葉神經算符的貢獻在計算之前是概念性的：您不是一次求解一個偏微分方程，而是參數化解算子本身，並且在傅立葉空間中執行此操作會產生一種架構，該架構是 $O(n \log n)$，在連續算子上通用，結構上解析度靈活。這是李等人的結論。 (2021) 以及上面運行的程式碼。

接下來是加速數字。文獻中的 100x-1000x 數字是在流動基準上根據很少說明質量的基線來測量的，本系列用整篇文章來展示這樣的標題通常有多少是演算法而不是硬體。證明將算子放入定價引擎中的合理性的主張——美分級 fp32 精度、有限的無套利違規率、在支付扭結中倖存的超分辨率，以及針對“有能力的”CPU 求解器的加速曲線——都是可測量的，在 Black-Scholes 上都很便宜，因為封閉形式存在，而且所有這些在這裡仍然無法測量。

這就是這份草案的狀態：這個機制是真實的，承諾是可信的，證據有待確定。

參考文獻與進一步閱讀：

• Li, Z.、Kovachki, N.、Azizzadenesheli, K. 等人。 “參數偏微分方程的傅立葉神經算符。” ICLR 2021。 arXiv:2010.08895
• Lu, L.、Jin, P.、Pang, G.、Zhang, Z. 和 Karniadakis, G.E. “透過 DeepONet 學習非線性算子。”自然機器智能，2021。 doi:10.1038/s42256-021-00302-5
• Li, Z. 等。 「用於學習偏微分方程的物理資訊神經算子。」ACM/IMS 數據科學雜誌，2024 年。 OpenReview
• neuraloperator PyTorch 庫：github.com/neuraloperator/neuraloperator
• 薩爾瓦多，M.，等人。 「用於選擇權定價的 Black-Scholes 方程式的神經網路學習。」[arXiv:2405.05780] (https://arxiv.org/abs/2405.05780)
• Bai，Y.，等人。 「AI Black-Scholes：金融資訊神經網路。」[arXiv:2412.12213] (https://arxiv.org/abs/2412.12213)