PDE Tabanlı Finansal Modelleme için Fourier Sinir Operatörü

Şu ana kadar bu blogdaki her sinir ağı, yaklaşık olarak bir işlev: özellik girişi ve bir sayı çıkışı sağladı. Fourier Sinir Operatörü, girdinin tam bir volatilite yüzeyi ve çıktının tam fiyat yüzeyi olduğu sonsuz boyutlu fonksiyon alanları arasındaki bir harita olan bir operatöre yaklaşır. Bu farklı bir nesnedir, farklı makinelere ihtiyaç duyar ve makine bu makalenin amacıdır: en düşük Fourier modlarına uygulanan, öğrenilebilir karmaşık değerli bir çekirdek, FFT gidiş-dönüş yoluyla değerlendirilir. $O(n \log n)$.

Opsiyon fiyatlandırması bunun finans alanına girdiği yerdir. Black-Scholes, Heston, yerel oynaklık — tüm PDE'ler, bugün hepsi birer birer parametre seti ile çözüldü. Operatör tüm parametre ailesini aynı anda öğrenir ve sonuçta ortaya çıkan ileri geçiş, zaman içinde ilerleyen bir döngü yerine tek bir toplu GPU çekirdeği olur.

Verilen söz budur. Bu makalenin dürüst versiyonu, aşağıdaki koddan sağlam ve tekrarlanabilir olan mekanizmaları, FNO literatüründe bu serideki hiç kimsenin incelenmeden kabul etmeyeceği temel değerlere göre rapor edilen performans iddialarından ayırır. Mekanikler önce gelir; ölçüm gündemi, yürütülmedi olarak işaretlenerek en sonunda gelir.

Fonksiyon Yaklaşımından Operatör Öğrenimine

Klasik sinir ağları yaklaşık fonksiyonlar: bir girdi verildiğinde $x \in \mathbb{R}^n$, bir çıktı üretirler $y \in \mathbb{R}^m$. Bu güçlüdür ancak ilgilenilen nesnelerin kendileri işlevler olduğunda temelde sınırlıdır. Finansal PDE çözümünde girdi tek bir sayı değildir; başlangıç/sınır koşullarını, volatilite yüzeyini veya vade yapısını açıklayan bir fonksiyondur. Çıktı başka bir işlevdir: Fiyat yüzeyinin üzerinde $(S, t)$ uzay.

Operatör öğrenimi sorunu sonsuz boyutlu uzaylara taşıyor. Öğrenmek yerine $f: \mathbb{R}^n \to \mathbb{R}^m$, bir operatör öğreniyoruz:

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

Neresi $\mathcal{A}$ Ve $\mathcal{U}$ fonksiyonların Banach uzaylarıdır. Opsiyon fiyatlandırması için $\mathcal{A}$ uçuculuk yüzeylerinin alanı olabilir $\sigma(S,t)$ Ve $\mathcal{U}$ karşılık gelen fiyat yüzeylerinin alanı $V(S,t)$.

Operatör öğrenim ortamına iki mimari hakimdir:

1. DeepONet (Lu ve diğerleri, 2021): Giriş işlevini kodlamak için bir şube ağı ve sorgu konumunu kodlamak için bir ana hat ağı kullanır. Çıktı onların iç ürünüdür. Chen ve Chen (1995) tarafından operatörler için evrensel yaklaşım teoremine dayandırılmıştır.

2. Fourier Sinir Operatörü (Li ve diğerleri, 2021): Verimli küresel evrişim için FFT'yi kullanarak Fourier uzayındaki integral çekirdeği parametreleştirir. Çözünürlük yapıya göre değişmez.

Her ikisi de sürekli operatörler için evrensel yaklaşımcılardır, ancak FNO'nun PDE problemleri için yapısal bir avantajı vardır: onun spektral sapması doğal olarak PDE çözümlerinin düzgün, küresel yapısını yakalar. Aynı zamanda, özellikle opsiyon getirileri açısından yapısal bir dezavantajı var; buna geri döneceğiz — kesik Fourier temeli ve grevdeki bükülme doğal müttefikler değil.

Ayrıntılı FNO Mimarisi

Li ve diğerleri tarafından tanıtılan Fourier Sinir Operatörü. ICLR 2021'de basit ama güçlü bir gözlem üzerine kuruludur: Birçok PDE'nin Green fonksiyonu (integral çekirdek), Fourier uzayında kompakt bir temsile sahiptir. Bir çekirdeği fiziksel alanda öğrenmek yerine - ki bu da gerektirir $O(n^2)$ için parametreler $n$ ızgara noktaları - FNO bunu frekans alanında yalnızca en düşük değerle öğrenir $k_{\max}$ karmaşıklığı azaltan modlar $O(n \log n)$ FFT aracılığıyla.

Yinelemeli Mimari

Bir FNO şunlardan oluşur:

1. Kaldırma katmanı $P$: Girişi orijinal kanal boyutundan daha yüksek boyutlu gizli bir temsile yansıtan noktasal doğrusal bir harita: $v_0(x) = P(a(x))$.

2. Fourier katmanları (tekrarlanan $L$ kez): Her katman geçerlidir:

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

Neresi $W_l$ yerel bir doğrusal dönüşümdür (noktasal olarak $1 \times 1$ evrişim) ve $\mathcal{K}_l$ FFT aracılığıyla uygulanan küresel bir integral operatörüdür:

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

Burada $\mathcal{F}$ FFT'yi belirtir, $R_l$ en düşük değere uygulanan öğrenilebilir karmaşık değerli bir ağırlık tensörüdür. $k_{\max}$ Fourier modları ve $\sigma$ noktasal doğrusal olmayan bir aktivasyondur (tipik olarak GELU).

3. Projeksiyon katmanı $Q$: Gizli gösterimi çıktı boyutuna geri eşler: $u(x) = Q(v_L(x))$.

Neden Fourier Uzayı?

Spektral evrişim $R_l \cdot \mathcal{F}(v_l)$ frekans alanında bir çarpımdır ve bu, fiziksel uzaydaki küresel bir evrişime eşdeğerdir, ancak şu şekilde hesaplanır: $O(n \log n)$ yerine $O(n^2)$. Bu sadece bir verimlilik hilesi değil. PDE solutions are typically smooth and dominated by low-frequency components. Kısaltarak $k_{\max}$ modlarında FNO, çözümü doğal olarak düzenleyen ve yüksek frekanslı artefaktları önleyen, öğrenilebilir bir alçak geçiş filtresi görevi görür.

En önemlisi, FNO'nun ayrıklaştırmayla değişmez olduğu iddia ediliyor: bir kez boyut ızgarası üzerinde eğitildikten sonra $n$, her türlü çözünürlükte değerlendirilebilir $m \neq n$ by simply adjusting the FFT size and zero-padding or truncating the spectral weights. Bu sıfır atışlı süper çözünürlük özelliği, nöral PDE çözücüler arasında benzersizdir ve bu makaledeki alıntıdan ziyade ölçümü hak eden ilk iddiadır. Aşağıdaki ölçüm gündemine bakın.

Operatörünü Öğrendiğimiz PDE

Türetilmiş, terim terim parçalara ayrılmış ve Black-Scholes Formülünde kapalı formda alım/satım çözümüyle birlikte verilen Black-Scholes PDE, operatörün hedefidir:

$\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$

Aşağıdaki her şey, cevabı bilinen bir kara kutu gibi ele alıyor. Bilinen cevap tam da bunun neden doğru test senaryosu olduğudur: sonlu fark çıktısı konusunda eğitim almış bir operatöre puan verilebilir. norm.cdf exact prices, which almost no FNO benchmark in the literature can do.

FNO Formülasyonu

Sorunu operatör öğrenmesi olarak yeniden şekillendiriyoruz. Tanımla:

• Giriş işlevi $a(S, t)$: PDE parametrelerini kodlar. Bu uçuculuk yüzeyini içerebilir $\sigma(S, t)$, getiri fonksiyonu ve kanallar üzerinde yığılmış risksiz oran $(S, t)$ ızgara.
• Çıkış fonksiyonu $u(S, t) = V(S, t)$: Opsiyon fiyat yüzeyi.

FNO öğrenir $\mathcal{G}_\theta: a \mapsto u$ bir veri kümesinden $(a^{(i)}, u^{(i)})$ geleneksel bir çözücü tarafından oluşturulan çiftler. Eğitimden sonra, herhangi bir yeni parametre konfigürasyonu için çıkarım tek bir ileri geçiştir.

Eğitim Verisi Oluşturma

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

Eğitim için binlerce parametre konfigürasyonunu örnekliyoruz; $\sigma \in [0.05, 0.80]$, $r \in [0.01, 0.10]$, $K \in [50, 150]$, $T \in [0.1, 2.0]$ — ve her birini sonlu farklar yöntemiyle çözün. Sonuçta ortaya çıkan girdi-çıktı çiftleri veri kümesi, FNO'nun öğrendiği şeydir.

Ölçeklendirme: Heston Stokastik Volatilite Modeli

Sürekli oynaklık bilinen-yanlış bir varsayımdır ve neden başarısız olduğu (gülümseme, kalın kuyruklar) Black-Scholes Formülü'in "Sert Gerçeklik" bölümünün konusudur. Heston, varyansı ikinci durum değişkeni haline getirerek sorunu düzeltiyor:

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

ile $\text{Corr}(dW_1, dW_2) = \rho$. Opsiyon fiyatına karşılık gelen PDE $V(S, v, t)$ uzayda iki boyutludur:

$\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$

Operatör öğreniminin önemini kazandığı nokta burasıdır ve argüman ampirik olmaktan ziyade yapısaldır. Sonlu fark şemaları $(S, v, t)$ ızgara ölçeği şu şekilde $O(N_S \times N_v \times N_t)$, çapraz türev terimi $\partial^2 V / \partial S \partial v$ ayrıklaştırmayı karmaşıklaştırır ve her yeni parametre seti $(\kappa, \theta, \xi, \rho, r)$ bedelinin tamamını tekrar öder. Operatör bunu eğitim sırasında bir kez öder. Heston PDE'nin 2 boyutlu uzamsal yapısı aynı zamanda Fourier katmanlarındaki 2 boyutlu FFT ile doğrudan eşleşir, böylece aşağıdaki mimari yeniden tasarım yerine boyut değişikliğiyle genelleşir.

Opsiyon Fiyatlandırması için FNO: PyTorch Uygulaması

Aşağıda Black-Scholes operatörünü öğrenmeye yönelik eksiksiz, bağımsız bir FNO uygulaması bulunmaktadır. Mimari Li ve diğerlerini takip ediyor. (2021) finansal ortama yönelik uyarlamalarla.

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)

Eğitim Döngüsü

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

Çıkarım: Gerçek Zamanlı Fiyatlandırma

@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 ve PINN'ler: Pratik Bir Karşılaştırma

Fizik Bilgili Sinir Ağları ve Fourier Sinir Operatörleri, PDE'leri sinir ağlarıyla çözmek için temelde farklı felsefeleri temsil eder. Bunların değiş tokuşlarını anlamak, operatörün öğrenimine önem vermenin pratik nedenidir.

PINN'ler: Örnek Başına Optimizasyon

PINN'ler, PDE kalıntısını doğrudan zarara sokar — Navier-Stokes Sorunu mekanizmayı, autodiff'i kapsar physics_loss uygulama ve DeepMind tekillik arama sonucu. Burada önemli olan tek özellik yapısaldır: Bir PINN, parametre seti başına eğitilir. $\sigma$, $r$, $K$ veya $T$ ve sıfırdan tekrar optimize edersiniz.

Güçlü yönler: Etiketlenmiş veri gerekmez. Doğrudan PDE yapısını uygular. Yazabileceğiniz herhangi bir PDE için çalışır.

Zayıf Yönler: Her yeni parametre seti için yeniden eğitim verilmesi gerekir $(\sigma, r, K, T)$. Eğitim, çoğu zaman optimizasyon patolojilerine yol açan çoklu kayıp terimlerinin (PDE kalıntısı, sınır koşulları, başlangıç ​​koşulları) dengelenmesini içerir. Yakınsama yavaş olabilir; genellikle sorun örneği başına 10.000-100.000 kademeli adım. Kayıp manzarasının son derece dışbükey olmadığı çok ölçekli ve kaotik sistemlerde başarısız olur.

FNO: Amorti Edilmiş Operatör Öğrenimi

FNO, çözüm operatörünü verilerden öğrenir. Klasik bir çözücü tarafından oluşturulan bir eğitim veri seti gerektirir, ancak bir kez eğitildikten sonra tüm parametre uzayına genellenir.

Güçlü Yönler: Yayınlanan kıyaslamalarda milisaniyenin altında çıkarım. Yeniden eğitim gerektirmeden görünmeyen parametrelere genelleme yapar. Çözünürlük değişmez — düşük çözünürlükte eğitin, yüksek çözünürlükte değerlendirin. Spektral önyargı yoluyla doğal olarak pürüzsüz PDE çözümlerini işler.

Zayıf Yönler: Klasik bir çözücüden (gerçekten yeni PDE'ler için tavuk ve yumurta problemi) eğitim verileri gerektirir. Yaklaşım hatası sınırlıdır ancak sıfır değildir. PDE-kısıtlı yaklaşımlara göre daha az yorumlanabilir. Ve sorunsuz çözümlere yardımcı olan spektral önyargı, getirisi açısından bir sorumluluktur.

Bire Bir Karşılaştırma

Aşağıdaki tablo literatürde rapor edilmiştir, burada ölçülmemiştir - özellikle doğruluk ve hızlanma satırları Li ve ark.'dan alınmıştır. (2021) ve donanımımızdaki opsiyon fiyatlandırmasından değil, değişken karşılaştırmalar üzerinde takip çalışması. Yapısal satırları (gerekli veriler, genelleme, çözüm değişmezliği) güvenilir olanlar olarak okuyun.

Hibrit: Fizik Bilgili Sinir Operatörleri (PINO)

PINO (Li ve diğerleri, 2024) her iki yaklaşımı birleştirir. FNO mimarisini kullanır ancak veriye dayalı kaybı PDE artık terimiyle artırır:

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

Ayrıştırma yararlı kısımdır. $\mathcal{L}_{\text{data}}$ operatörü, nerede olursanız olun çözücü çıktısına bağlar; $\lambda \mathcal{L}_{\text{PDE}}$ hiç örneklemediğiniz parametre alanı bölgeleri de dahil olmak üzere, bunu yapmadığınız her yerde kısıtlar. Opsiyon fiyatlaması için bu ikinci terim, finansa özgü bir nedenden dolayı caziptir: PDE kalıntısı, çıkarım zamanında aşağıdaki kalan izleme geri dönüşünün temeli olan bir kendi kendine kontrol olarak da değerlendirebileceğiniz zor bir kısıtlamadır.

Üretim Dağıtımı için Pratik Hususlar

Bunun genel yarısı (çıkarsama gecikme bütçeleri, veri hattını oluşturmak, sürüklenmeyi izlemek, periyodik yeniden eğitim) DeepLOB: Limit Order Books'ta Derin Öğrenme üretim bölümünde bir ticaret sistemindeki sinir modeli için zaten kapsanmaktadır ve değişmeden uygulanır. Aşağıda sadece bir operatöre özel olan anlatılmaktadır.

Veri Hattı: Parametre Uzayını Örnekleme

Eğitim verilerinin oluşturulması ana darboğazdır ve piyasa verileri modelinden farklı olarak, kendi dağıtımınızı seçersiniz; bu, kayıpta görünmeyen bir şekilde yanlış yapabileceğiniz anlamına gelir. 4 parametreli Black-Scholes operatörü için 5.000–10.000 örnek yeterlidir. 5 parametre artı 2 boyutlu uzaysal alana sahip Heston için 20.000-50.000 örnek tipiktir. Uyarlanabilir örneklemeyi kullanın: numuneleri çözümün hızlı bir şekilde değiştiği (paraya yakın, kısa vadeler, yüksek oynaklık) parametre bölgelerinde yoğunlaştırın, çünkü kutunun tekdüze örneklemesi bütçesinin çoğunu operatörün neredeyse doğrusal olduğu ve çok az örnekten iyi şeyler öğrendiği derin ITM ve derin OTM bölgelerine harcıyor.

Mimari Ayarlama

• Modlar ($k_{\max}$): Şununla başla: $N/4$ Neresi $N$ uzaysal ızgara boyutudur. İçin $N=256$32-64 modlarını kullanın. Çok az sayıda mod, saldırı sınırlarına yakın yerlerde ayrıntıları kaybeder; gürültüye aşırı uyum.
• Katmanlar: 4 Fourier katmanı standarttır. Daha derin ağlar (6-8), Heston gibi 2 boyutlu sorunlara yardımcı olur ancak belleği artırır.
• Gizli kanallar: 1D Black-Scholes için 64, 2D Heston için 128. Sorunun karmaşıklığına göre ölçeklendirin.

Hassasiyet: FP32 Sorusu

SpectralConv1d tahsis eder torch.cfloat — tek duyarlıklı karmaşık — ve her FFT gidiş-dönüş bu hassasiyette çalışır. Bu blog, matematiksel olarak doğru bir önek toplamı formülasyonunun fp32 büyüklüklerinde feci şekilde kaybolduğu The GPU Precision Trap'te bir fp32 finansal hattının sessiz çöpe dönüşünü zaten izledi. Buradaki benzer soru doğrudandır: $S \approx 100$ fiyatlar sent bazında verildiğinde, fp32 spektral gidiş-dönüş $10^{-2}$ mutlak mı, yoksa FFT'nin orta büyüklükteki büyümesi son önemli rakamları mı yiyor?

Hata Kontrolü

Üretim seçeneği fiyatlandırması için savunabileceğiniz hata sınırlarına ihtiyacınız vardır.

1. Kalibre edilmiş belirsizlik: bir topluluk standart sapması bir kapsam garantisi değildir ve bu blog bunu doğru şekilde yapacak mekanizmaya sahiptir - Riske Duyarlı Pozisyon Boyutlandırması için Uyumlu Tahmin bölümünde değiştirilemeyen durum için ACI/DtACI ile uzatılmış bir parametre ızgarası üzerinden bölünmüş konformal. FNO'yu bölünmüş konformal olarak sarmak $(\sigma, r, K, T)$ ızgara fiyat üzerinde dağıtımsız aralıklar verir.
2. Artık izleme: FNO tahmininin PDE kalıntısını geçici bir kontrol olarak hesaplayın. Eğer $\|\text{residual}\| > \epsilon$, klasik bir çözücüye geri dönelim. Bu, çıkarımda ücretsizdir; artık, halihazırda sahip olduğunuz bir dizideki sonlu fark kalıbıdır.
3. Aktif öğrenme: Yüksek belirsizliğe sahip girdileri klasik çözücüye yönlendirin, sonuçları eğitim setine ekleyin ve periyodik olarak yeniden eğitim verin. (1)'deki uyumlu aralık genişliği doğal yönlendirme sinyalidir.

Ölçüm Gündemi

Yukarıdaki mimarinin konuşlandırılmaya değer olup olmadığına karar veren kısım budur ve henüz hiçbiri yapılmamıştır. Gömülmek yerine burada listelenmiştir çünkü alternatif - manşet hızlandırma iddiası - tam olarak bu blogun kaçınmak için var olduğu kayıttır.

1. Hızlanma bir sayı değil, bir eğridir. GPU Karşılığını Çıkardığında şu şekli oluşturur: $S(B) = aB/(O + bB)$, genel giderlerin hakim olduğu yerden yükselen $B=1$ hesaplamaya bağlı bir platoya doğru gidiyor ve 167x başlığın 27x algoritma çarpı 6,2x donanıma ayrıştığını gösteriyor. FNO ölçümü şu şablona uymalıdır: ileri geçişi duvar saati ile ölçün. $B \in \{1, 8, 64, 512\}$ ve tüm eğriyi rapor edin. Kritik olarak, taban çizgisi vektörleştirilmiş, çok çekirdekli sonlu farklar çözücü olmalıdır. black_scholes_fd yukarıda yorumlanmış bir çift döngü var, makalenin adlandırdığı tam "en kötü CPU uygulaması" temeli ve toplu GPU operatörünün bununla karşılaştırılması hiçbir şey ifade etmeyen bir sayı üretecektir.

2. Kapalı forma karşı doğruluk. Bu, Black-Scholes'un neredeyse bedava yaptığı ve akışkan dinamiği kıyaslamalarının hiçbir şekilde yapamadığı bir deneydir: FD tarafından oluşturulan veriler üzerinde eğitim alın, ardından tam olarak puan alın norm.cdf genelindeki fiyatlar $(\sigma, r, K, T)$ kutu. Akrabayı bildirin $L^2$ve dağılımı hatasını bildirin — özellikle çözümün en az düzgün olduğu ve kesik spektral temelin en çok zorluk yaşayacağı vuruşun yakınında ve vadenin dolmasına yakın.

3. Arbitraj ihlali yok. Bilgili bir operatörün, bir fiyat yüzeyinin karşılaması gereken şekil kısıtlamalarına saygı duymak için hiçbir yapısal nedeni yoktur: tekdüzelik $K$, dışbükeylik $K$, Ve $V \geq \max(S-K, 0)$. Parametre kutusu üzerinden ihlal oranının ölçülmesi, bu makalenin kendi açık sorusunu - öğrenilmiş operatörde arbitraj yapılmaması koşullarını garanti edebilir miyiz? - el sallamaktan bir sayıya dönüştürür.

4. Ayrıklaştırma değişmezliği iddia edilmek yerine test edilmiştir. Eğitim $N_S = 128$, değerlendir $N_S = 512$, hatayı bildirin. Beklenen arıza modunun adı ve spesifikliği şu şekildedir: Gibbs bükülme anında çalıyor $\max(S-K, 0)$. Süreksiz bir birinci türevi olan bir fonksiyonu yeniden oluşturan kesik bir Fourier temeli, onun etrafında salınır ve sıfır atışlı süper çözünürlük, eğitim çözünürlüğünün hiç görmediği modları açığa çıkararak bunu daha iyi yerine daha da kötü hale getirebilir. Eğer süper çözünürlük hedefe yakın bir zamanda düşerse, bu olumsuz sonuç, yerini aldığı pazarlama iddiasından daha değerli olur; FNO literatüründe hiç kimse, seçenekleri kazançlı bir şekilde fiyatlandırmaz.

1-4 arasındaki deneyler çalıştırılamazsa bu makale gönderilmemelidir. Onlar olmadan geriye kalan, başka birinin ICLR makalesinin iyi yazılmış bir açıklamasıdır.

Vanilya Seçeneklerinin Ötesinde

Yukarıdaki gündemin ölçümle temas halinde varlığını sürdüreceğini varsayarsak, FNO çerçevesi doğal olarak daha karmaşık araçları da kapsayacak şekilde genişler:

• Amerikan seçenekleri: Ek bir çıkış kanalı olarak erken egzersiz sınırı ekleyin. FNO hem fiyat yüzeyini hem de optimal kullanım sınırını aynı anda öğrenir.
• Bariyer seçenekleri: Bariyer seviyelerini giriş kanalları olarak kodlayın. Bir engelin ikinci bir süreksizlik olduğunu ve Gibbs'in ölçüm gündemindeki endişesinin daha az değil, daha güçlü bir şekilde geçerli olduğunu unutmayın.
• Çok varlıklı sepetler: 2-3 temeldeki sepet seçenekleri için 2D veya 3D FNO'yu kullanın. Boyutsallığın laneti ızgara tabanlı çözücülere göre daha az şiddetlidir çünkü FNO sabit sayıda modda çalışır.
• Yerel oynaklık: Dupire yerel oynaklık yüzeyinin tamamını girin $\sigma_{\text{loc}}(S,t)$ uzaysal bir fonksiyon olarak Bu, operatörün öğrenmesi için en doğal kullanım durumudur; giriş bir fonksiyondur, skaler bir parametre değil.

Sonuç

Fourier Sinir Operatörünün katkısı, hesaplamadan önce kavramsaldır: her seferinde bir PDE çözmek yerine, çözüm operatörünün kendisini parametreleştirirsiniz ve bunu Fourier uzayında yapmak, şu şekilde bir mimari sağlar: $O(n \log n)$, sürekli operatörlerde evrenseldir ve yapısı gereği çözünürlük açısından esnektir. Bu kadarı Li ve ark. (2021) ve yukarıdaki çalışan koddan.

Takip etmeyen şey bir hızlandırma numarasıdır. Literatürün 100x-1000x rakamları, kalitesi nadiren belirtilen temel çizgilere göre değişken kıyaslamalarla ölçülmüştür ve bu seri, böyle bir başlığın ne kadarının genellikle donanımdan ziyade algoritmadan oluştuğunu gösteren bir makalenin tamamını harcamıştır. Bir operatörü bir fiyatlandırma motoruna koymayı haklı çıkaracak iddiaların (yüzdelik fp32 doğruluğu, sınırlı arbitraj ihlali oranı, getiri karışıklığından kurtulan süper çözünürlük ve yeterli bir CPU çözücüye karşı hızlanma eğrisi) hepsi ölçülebilir, kapalı form mevcut olduğu için Black-Scholes'ta hepsi ucuz ve burada hepsi hala ölçülmüyor.

Bu taslağın durumu bu: Mekanizma gerçek, vaatler makul ve kanıtlar beklemede.

Referanslar ve daha fazla okuma:

• Li, Z., Kovachki, N., Azizzadenesheli, K., ve diğerleri. "Parametrik Kısmi Diferansiyel Denklemler için Fourier Sinir Operatörü." ICLR 2021. arXiv:2010.08895
• Lu, L., Jin, P., Pang, G., Zhang, Z. ve Karniadakis, G.E. "DeepONet aracılığıyla doğrusal olmayan operatörleri öğrenme." Doğa Makine Zekası, 2021. doi:10.1038/s42256-021-00302-5
• Li, Z. ve diğerleri. "Kısmi Diferansiyel Denklemleri Öğrenmek için Fizik Bilgili Sinir Operatörü." ACM/IMS Veri Bilimi Dergisi, 2024. OpenReview
• neuraloperator PyTorch kütüphanesi: github.com/neuraloperator/neuraloperator
• Salvador, M., ve diğerleri. "Seçenek Fiyatlandırması için Black-Scholes Denklemini Sinir Ağı Öğrenimi." arXiv:2405.05780
• Bai, Y. ve diğerleri. "AI Black-Scholes: Finans Bilgili Sinir Ağı." arXiv:2412.12213