PDE ベースの財務モデリング用のフーリエ ニューラル演算子

これまでのところ、このブログのすべてのニューラル ネットワークは、特徴が入力され、数値が出力される 関数 に近似しています。フーリエ ニューラル演算子は、演算子、つまり無限次元の関数空間間のマップを近似します。ここで、入力はボラティリティ曲面全体、出力は価格曲面全体です。それは別のオブジェクトであり、別の機械が必要であり、その機械がこの記事のポイントです。学習可能な複素数値カーネルが最も低いフーリエ モードに適用され、FFT ラウンドトリップを通じて評価されます。 $O(n \log n)$。

オプションの価格設定は、これが金融に着目するところです。ブラック・ショールズ、ヘストン、ローカル ボラティリティ - すべての偏微分方程式は、今日一度に 1 つのパラメーター セットで解決されました。オペレーターはパラメーター ファミリ全体を一度に学習し、その結果として得られるフォワード パスは、時間進行ループではなく、単一のバッチ処理された 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)$。

オペレーターの学習環境では 2 つのアーキテクチャが支配的です。

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 ソルバーの中でも独特であり、これは引用ではなく測定に値するこの記事の最初の主張です。以下の測定アジェンダを参照してください。

演算子を学習している PDE

Black-Scholes 偏微分方程式は、項ごとに導出され、詳細に分析され、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 は、分散を 2 番目の状態変数にすることでこの問題を修正しました。

$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$。オプション価格の対応する偏微分方程式 $V(S, v, t)$ 空間内の 2 次元です。

$\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 の実装

以下は、Black-Scholes 演算子を学習するための完全な自己完結型 FNO 実装です。アーキテクチャは 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 は偏微分方程式残差を直接損失に反映します — ナビエ・ストークス問題 では、autodiff のメカニズムについて説明しています。 physics_loss 実装、および DeepMind 特異点検索の結果。ここで重要なプロパティは構造的なものだけです。 PINN はパラメータ セットごとにトレーニングされます。 変更 $\sigma$, $r$, $K$ または $T$ そして再び最初から最適化します。

長所: ラベル付きデータは必要ありません。 PDE 構造を直接適用します。書き留めることができる任意の偏微分方程式で機能します。

弱点: 新しいパラメータセットごとに再トレーニングする必要がある $(\sigma, r, K, T)$。トレーニングには、複数の損失項 (PDE 残差、境界条件、初期条件) のバランスをとることが含まれており、多くの場合、最適化の病理につながります。収束は遅くなる可能性があり、通常は問題インスタンスごとに 10,000 ～ 100,000 の勾配ステップがかかります。損失の状況が高度に非凸になる、マルチスケールでカオスなシステムでは失敗します。

FNO: 償却されたオペレーター学習

FNO はデータから解演算子を学習します。従来のソルバーによって生成されたトレーニング データセットが必要ですが、トレーニングが完了すると、パラメーター空間全体にわたって一般化されます。

長所: 公開されたベンチマークにおけるミリ秒未満の推論。再トレーニングせずに、目に見えないパラメータに一般化します。解像度不変 — 低解像度でトレーニングし、高解像度で評価します。スペクトル バイアスを介してスムーズな PDE 解を自然に処理します。

弱点: 古典的なソルバーからのトレーニング データが必要です (真に新しい偏微分方程式に対する鶏が先か卵が先かの問題)。近似誤差には制限がありますが、ゼロではありません。 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}}$ サンプリングしていないパラメータ空間の領域を含め、サンプリングしていないあらゆる場所で制約します。オプション価格設定の場合、第 2 項は金融に特有の理由から魅力的です。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) はヘストンのような 2D 問題に役立ちますが、メモリが増加します。
• 隠しチャンネル: 1D Black-Scholes の場合は 64、2D Heston の場合は 128。問題の複雑さに応じてスケールします。

精度: fp32 の質問

SpectralConv1d 割り当てる torch.cfloat — 単精度複素数 — すべての FFT ラウンドトリップはその精度で実行されます。このブログでは、fp32 金融パイプラインが GPU 精度の罠 でサイレント ガベージを返すことをすでに観察しました。そこでは、数学的に正しいプレフィックス合計の定式化が 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 は、価格表面と最適行使境界の両方を同時に学習します。
• バリア オプション: バリア レベルを入力チャンネルとしてエンコードします。バリアは 2 番目の不連続点であり、測定アジェンダからのギブズの懸念は、それ以下ではなく、より強力に適用されることに注意してください。
• マルチアセット バスケット: 2 ～ 3 の原資産のバスケット オプションには 2D または 3D FNO を使用します。 FNO は固定数のモードで動作するため、次元の呪いはグリッドベースのソルバーほど深刻ではありません。
• ローカル ボラティリティ: Dupire の完全なローカル ボラティリティ曲面を入力します。 $\sigma_{\text{loc}}(S,t)$ 空間関数として。これは演算子の学習にとって最も自然な使用例です。つまり、入力はスカラー パラメーターではなく関数です。

結論

フーリエ ニューラル演算子の貢献は、計算的である前に概念的なものです。一度に 1 つの偏微分方程式を解く代わりに、解演算子自体をパラメーター化し、それをフーリエ空間で行うことで、次のようなアーキテクチャが得られます。 $O(n \log n)$、連続演算子で普遍的であり、構造により解像度が柔軟です。 Li et al. の論文から多くのことがわかります。 (2021) と実行される上記のコードから。

これに続くものは高速化の数値です。文献の 100 倍から 1,000 倍の数値は、その品質がほとんど表明されていないベースラインに対する流動的なベンチマークで測定されており、このシリーズでは記事全体を費やして、そのような見出しのどれだけが通常、ハードウェアではなくアルゴリズムであるかを示しました。オペレーターを価格設定エンジンに投入することを正当化する主張、つまりセントレベルの 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 を介して非線形演算子を学習する。」 Nature Machine Intelligence、2021. doi:10.1038/s42256-021-00302-5
• リー、Z. 他「偏微分方程式を学習するための物理学に基づいたニューラル オペレーター」 ACM/IMS データ サイエンス ジャーナル、2024 年。オープンレビュー
• neuraloperator PyTorch ライブラリ: github.com/neuraloperator/neuraloperator
• サルバドール、M.、他。 「オプション価格設定のためのブラック・ショールズ方程式のニューラルネットワーク学習」 arXiv:2405.05780
• Bai、Y.、他。 「AI ブラック・ショールズ: 金融情報に基づいたニューラル ネットワーク」。 arXiv:2412.12213