PDE 기반 금융 모델링을 위한 푸리에 신경 연산자

지금까지 이 블로그의 모든 신경망은 기능(기능 입력, 숫자 출력)에 근접했습니다. 푸리에 신경 연산자는 입력이 전체 변동성 표면이고 출력이 전체 가격 표면인 무한 차원 함수 공간 간의 맵인 연산자와 유사합니다. 그것은 다른 객체이고, 다른 기계가 필요하며, 기계는 이 기사의 요점입니다. 가장 낮은 푸리에 모드에 적용되는 학습 가능한 복소수 커널은 FFT 왕복을 통해 평가됩니다. $O(n \log n)$.

옵션 가격 책정은 이것이 금융에 해당하는 부분입니다. Black-Scholes, Heston, 로컬 변동성 — 모든 PDE는 모두 한 번에 하나의 매개변수 세트로 해결되었습니다. 운영자는 전체 매개변수 계열을 한 번에 학습하며, 결과적인 정방향 패스는 시간 이동 루프가 아닌 단일 배치 GPU 커널입니다.

그것이 약속입니다. 이 기사의 정직한 버전은 아래 코드에서 견고하고 재현 가능한 메커니즘을 FNO 문헌에서 보고된 성능 주장과 이 시리즈의 누구도 검토하지 않은 기준으로 받아들이지 않을 기준에 대해 보고한 것으로 분리합니다. 역학이 우선입니다. 측정 안건은 마지막에 나타나며 실행되지 않은 것으로 표시됩니다.

함수 근사에서 연산자 학습까지

고전 신경망의 대략적인 기능: 입력이 주어지면 $x \in \mathbb{R}^n$, 그들은 출력을 생성합니다 $y \in \mathbb{R}^m$. 이는 강력하지만 관심 객체 자체가 함수인 경우 근본적으로 제한됩니다. 금융 PDE 해결에서 입력은 단일 숫자가 아닙니다. 이는 초기/경계 조건, 변동성 표면 또는 기간 구조를 설명하는 함수입니다. 출력은 또 다른 기능입니다: 가격 표면 $(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에서는 간단하지만 강력한 관찰을 기반으로 합니다. 즉, 많은 PDE의 그린 함수(적분 커널)가 푸리에 공간에서 간결하게 표현됩니다. 물리적 공간에서 커널을 학습하는 대신 — $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 PDE는 파생되고 용어별로 분석되며 Black-Scholes 공식의 폐쇄형 콜/풋 솔루션과 함께 제공되며 연산자 대상입니다.

$\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 확률적 변동성 모델

지속적인 변동성은 잘못된 가정으로 알려져 있으며, 이것이 실패하는 이유(미소, 뚱뚱한 꼬리)는 The Black-Scholes Formula의 "가혹한 현실" 섹션의 주제입니다. 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)$ 공간에서는 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 et al. (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: 실제 비교

물리학 기반 신경망과 푸리에 신경망 연산자는 신경망을 사용하여 PDE를 해결하는 데 있어 근본적으로 다른 철학을 나타냅니다. 이들의 장단점을 이해하는 것이 운영자 학습에 관심을 갖는 실질적인 이유입니다.

PINN: 인스턴스별 최적화

PINN은 PDE 잔차를 직접적으로 손실에 넣습니다. - Navier-Stokes 문제는 autodiff 메커니즘을 다룹니다. physics_loss 구현 및 DeepMind 특이점 검색 결과. 여기서 중요한 유일한 속성은 구조적입니다. PINN은 매개변수 세트별로 학습됩니다. 변경 $\sigma$, $r$, $K$ 또는 $T$ 처음부터 다시 최적화합니다.

강점: 라벨이 붙은 데이터가 필요하지 않습니다. PDE 구조를 직접 적용합니다. 적어둘 수 있는 모든 PDE에 대해 작동합니다.

약점: 새로운 매개변수 세트마다 재학습해야 함 $(\sigma, r, K, T)$. 훈련에는 종종 최적화 병리로 이어지는 여러 손실 조건(PDE 잔차, 경계 조건, 초기 조건)의 균형이 포함됩니다. 수렴은 느릴 수 있습니다. 일반적으로 문제 인스턴스당 10,000~100,000개의 그라데이션 단계입니다. 손실 환경이 볼록하지 않게 되는 다중 규모 및 혼란스러운 시스템에서는 실패합니다.

FNO: 상각된 운영자 학습

FNO는 데이터로부터 솔루션 연산자를 학습합니다. 기존 솔버에서 생성된 교육 데이터 세트가 필요하지만 일단 교육을 받은 후에는 전체 매개변수 공간에 걸쳐 일반화됩니다.

강점: 게시된 벤치마크에서 밀리초 미만의 추론이 가능합니다. 재교육 없이 보이지 않는 매개변수로 일반화합니다. 해상도 불변 — 낮은 해상도에서 훈련하고 높은 해상도에서 평가합니다. 스펙트럼 바이어스를 통해 자연스럽게 PDE 솔루션을 처리합니다.

약점: 기존 솔버의 훈련 데이터가 필요합니다(진정한 새로운 PDE의 경우 닭고기와 달걀 문제). 근사 오류는 제한되어 있지만 0이 아닙니다. PDE 제한 접근 방식보다 해석하기가 어렵습니다. 그리고 원활한 솔루션에 도움이 되는 스펙트럼 편향은 보상 꼬임에 대한 책임입니다.

정면 비교

아래 표는 여기서 측정된 것이 아니라 문헌 보고된 것입니다. 특히 정확도 및 속도 향상 행은 Li et al.에서 가져온 것입니다. (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,00010,000개의 샘플이면 충분합니다. 5개의 매개변수와 2D 공간 도메인을 갖춘 Heston의 경우 일반적으로 20,00050,000개의 샘플이 사용됩니다. 적응형 샘플링 사용: 박스의 균일한 샘플링은 운영자가 거의 선형이고 아주 적은 예에서 잘 학습하는 deep-ITM 및 deep-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$ 컴퓨팅 바운드 고원으로 이동하고 167x의 헤드라인이 27x의 알고리즘과 6.2x의 하드웨어로 분해되는 것을 보여줍니다. 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$, 오류를 보고하세요. 예상되는 실패 모드는 이름이 지정되고 구체적입니다. Gibbs ringing at the kink $\max(S-K, 0)$. 불연속적인 1차 도함수를 사용하여 함수를 재구성하는 잘린 푸리에 기반은 그 주위에서 진동하며, 제로 샷 초해상도는 훈련 분해능이 본 적이 없는 모드를 노출함으로써 이를 더 좋게 만들기보다는 더 나쁘게 만들 수 있습니다. 초해상도가 파업 근처에서 저하되면 그 부정적인 결과는 그것이 대체하는 마케팅 주장보다 더 가치가 있습니다. FNO 문헌의 어느 누구도 옵션에 보상을 제공하는 가격을 책정하지 않습니다.

실험 1~4를 실행할 수 없는 경우 이 문서가 제공되지 않습니다. 그것들 없이는 다른 사람의 ICLR 논문에 대해 잘 쓰여진 설명이 남아 있습니다.

바닐라 옵션 그 이상

위의 안건이 측정과의 접촉에서 살아남는다고 가정하면 FNO 프레임워크는 자연스럽게 더 복잡한 도구로 확장됩니다.

• 미국식 옵션: 추가 출력 채널로 초기 운동 경계를 추가합니다. FNO는 가격 표면과 최적의 행사 경계를 동시에 학습합니다.
• 배리어 옵션: 배리어 레벨을 입력 채널로 인코딩합니다. 장벽은 두 번째 불연속성이며 측정 의제에서 Gibbs의 우려는 더 큰 힘으로 적용됩니다.
• 다중 자산 바스켓: 2~3개 기초에 대한 바스켓 옵션에 2D 또는 3D FNO를 사용합니다. FNO는 고정된 수의 모드에서 작동하기 때문에 차원의 저주는 그리드 기반 솔버보다 덜 심각합니다.
• 로컬 변동성: 전체 Dupire 로컬 변동성 표면을 입력합니다. $\sigma_{\text{loc}}(S,t)$ 공간 함수로. 이는 연산자 학습의 가장 자연스러운 사용 사례입니다. 입력은 스칼라 매개변수가 아니라 함수입니다.

결론

푸리에 신경 연산자의 기여는 계산에 앞서 개념적입니다. 한 번에 하나의 PDE를 푸는 대신 솔루션 연산자 자체를 매개변수화하고 푸리에 공간에서 이를 수행하면 다음과 같은 아키텍처가 생성됩니다. $O(n \log n)$, 연속 연산자에 보편적이며 구성에 따라 분해능이 유연합니다. 이는 Li et al. (2021) 및 위의 코드에서 실행됩니다.

따르지 않는 것은 속도 향상 수치입니다. 문헌의 100x-1000x 수치는 품질이 거의 언급되지 않은 기준에 대한 유동적인 벤치마크에서 측정되었으며, 이 시리즈는 그러한 헤드라인 중 하드웨어가 아닌 알고리즘이 얼마나 많은지를 보여주는 전체 기사를 소비했습니다. 가격 책정 엔진에 운영자를 포함시키는 것을 정당화하는 주장(센트 수준의 fp32 정확도, 제한된 차익거래 위반률, 보상 꼬임에서 살아남는 초해상도, 유능한 CPU 솔버에 대한 속도 향상 곡선)은 모두 측정 가능하며 닫힌 형식이 존재하기 때문에 Black-Scholes에서는 모두 저렴하지만 여기서는 모두 아직 측정되지 않습니다.

이것이 바로 이 초안의 상태입니다. 메커니즘은 실제이고 약속은 그럴듯하며 증거가 보류 중입니다.

참고자료 및 추가 자료:

• Li, Z., Kovachki, N., Azizzadenesheli, K., et al. “파라메트릭 편미분 방정식을 위한 푸리에 신경 연산자.” 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
• Li, Z., et al. "편미분 방정식 학습을 위한 물리학 기반의 신경 연산자." ACM/IMS 데이터 과학 저널, 2024. OpenReview
• neuraloperator PyTorch 라이브러리: github.com/neuraloperator/neuraloperator
• 살바도르, M., 외. "옵션 가격 책정에 대한 블랙숄즈 방정식의 신경망 학습." arXiv:2405.05780
• 바이, Y., 외. “AI 블랙숄즈: 금융 정보를 활용한 신경망.” arXiv:2412.12213