Operator Neural Fourier untuk Pemodelan Kewangan Berasaskan PDE

Setiap rangkaian saraf di blog ini setakat ini telah menganggarkan fungsi: ciri masuk, nombor keluar. Operator Neural Fourier menghampiri pengendali — peta antara ruang fungsi dimensi tak terhingga, dengan input ialah permukaan turun naik keseluruhan dan output ialah permukaan keseluruhan harga. Itu adalah objek yang berbeza, ia memerlukan jentera yang berbeza, dan jentera adalah inti dari artikel ini: kernel bernilai kompleks yang boleh dipelajari digunakan pada mod Fourier terendah, dinilai melalui perjalanan pergi balik FFT dalam $O(n \log n)$.

Penetapan harga opsyen adalah tempat ini berada dalam kewangan. Black-Scholes, Heston, turun naik tempatan — semua PDE, semuanya diselesaikan hari ini satu set parameter pada satu masa. Pengendali mempelajari keseluruhan keluarga parameter sekaligus, dan hantaran hadapan yang terhasil ialah kernel GPU berkelompok tunggal dan bukannya gelung perarakan masa.

Itulah janji. Versi jujur ​​artikel ini memisahkan mekanik, yang kukuh dan boleh dihasilkan semula daripada kod di bawah, daripada tuntutan prestasi, yang dalam literatur FNO dilaporkan terhadap garis dasar tiada siapa dalam siri ini akan menerima tanpa diperiksa. Mekanik diutamakan; agenda pengukuran datang pada penghujung, ditandai sebagai belum dijalankan.

Daripada Penghampiran Fungsi kepada Pembelajaran Operator

Rangkaian saraf klasik fungsi anggaran: diberi input $x \in \mathbb{R}^n$, mereka menghasilkan output $y \in \mathbb{R}^m$. Ini berkuasa, tetapi pada asasnya terhad apabila objek yang menarik itu sendiri berfungsi. Dalam penyelesaian PDE kewangan, input bukan nombor tunggal — ia adalah fungsi yang menerangkan keadaan awal/sempadan, permukaan turun naik atau struktur istilah. Output adalah fungsi lain: permukaan harga berakhir $(S, t)$ angkasa lepas.

Pembelajaran operator mengangkat masalah kepada ruang dimensi tak terhingga. Daripada belajar $f: \mathbb{R}^n \to \mathbb{R}^m$, kita belajar operator:

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

di mana $\mathcal{A}$ dan $\mathcal{U}$ ialah ruang fungsi Banach. Untuk harga pilihan, $\mathcal{A}$ mungkin ruang permukaan turun naik $\sigma(S,t)$ dan $\mathcal{U}$ ruang permukaan harga yang sepadan $V(S,t)$.

Dua seni bina mendominasi landskap pembelajaran operator:

1. DeepONet (Lu et al., 2021): Menggunakan rangkaian cawangan untuk mengekod fungsi input dan rangkaian batang untuk mengekod lokasi pertanyaan. Keluaran adalah produk dalaman mereka. Berasaskan dalam teorem penghampiran universal untuk pengendali oleh Chen dan Chen (1995).

2. Fourier Neural Operator (Li et al., 2021): Parameterkan inti integral dalam ruang Fourier, menggunakan FFT untuk konvolusi global yang cekap. Resolusi-invarian mengikut pembinaan.

Kedua-duanya adalah penghampir universal untuk pengendali berterusan, tetapi FNO mempunyai kelebihan struktur untuk masalah PDE: bias spektrumnya secara semula jadi menangkap struktur global penyelesaian PDE yang lancar. Ia juga mempunyai kelemahan struktur untuk pembayaran pilihan secara khusus, yang akan kami kembalikan — asas Fourier yang dipenggal dan kelemahan pada mogok bukanlah sekutu semula jadi.

Senibina FNO secara Terperinci

Operator Neural Fourier, yang diperkenalkan oleh Li et al. di ICLR 2021, dibina di atas pemerhatian yang ringkas tetapi berkuasa: fungsi Hijau (irung bersepadu) bagi banyak PDE mempunyai perwakilan padat dalam ruang Fourier. Daripada mempelajari kernel dalam ruang fizikal — yang memerlukan $O(n^2)$ parameter untuk $n$ mata grid — FNO mempelajarinya dalam ruang frekuensi dengan hanya yang terendah $k_{\max}$ mod, mengurangkan kerumitan kepada $O(n \log n)$ melalui FFT.

Seni Bina Berulang

FNO terdiri daripada:

1. Lapisan mengangkat $P$: Peta linear mengikut arah yang menayangkan input daripada dimensi saluran asalnya kepada perwakilan terpendam dimensi yang lebih tinggi: $v_0(x) = P(a(x))$.

2. Empat lapisan (diulang $L$ kali): Setiap lapisan digunakan:

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

di mana $W_l$ ialah transformasi linear tempatan (mengikut arah mata $1 \times 1$ lilitan) dan $\mathcal{K}_l$ ialah pengendali integral global yang dilaksanakan melalui FFT:

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

Di sini $\mathcal{F}$ menandakan FFT, $R_l$ ialah tensor berat bernilai kompleks yang boleh dipelajari digunakan pada yang terendah $k_{\max}$ Mod Fourier, dan $\sigma$ ialah pengaktifan tak linear mengikut arah (biasanya GELU).

3. Lapisan unjuran $Q$: Petakan perwakilan terpendam kembali ke dimensi output: $u(x) = Q(v_L(x))$.

Mengapa Fourier Space?

Konvolusi spektrum $R_l \cdot \mathcal{F}(v_l)$ ialah pendaraban dalam domain kekerapan, yang bersamaan dengan lilitan global dalam ruang fizikal — tetapi dikira dalam $O(n \log n)$ bukannya $O(n^2)$. Ini bukan hanya helah kecekapan. Penyelesaian PDE biasanya lancar dan dikuasai oleh komponen frekuensi rendah. Dengan memotong ke $k_{\max}$ mod, FNO bertindak sebagai penapis laluan rendah yang boleh dipelajari yang secara semula jadi menyelaraskan penyelesaian dan mengelakkan artifak frekuensi tinggi.

Yang penting, FNO didakwa sebagai discretization-invariant: sekali dilatih pada grid saiz $n$, ia boleh dinilai pada sebarang resolusi $m \neq n$ dengan hanya melaraskan saiz FFT dan sifar padding atau memotong berat spektrum. Sifat peleraian super sifar ini adalah unik dalam kalangan penyelesai PDE saraf — dan ia merupakan tuntutan pertama dalam artikel ini yang patut diukur dan bukannya petikan. Lihat agenda pengukuran di bawah.

PDE Kami Belajar Operator Untuk

Black-Scholes PDE — terbitan, dibedah istilah mengikut istilah, dan diberikan dengan penyelesaian panggilan/letakkan bentuk tertutupnya dalam Formula Black-Scholes — ialah sasaran pengendali:

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

Semua yang berikut menganggapnya sebagai kotak hitam dengan jawapan yang diketahui. Jawapan yang diketahui itulah sebabnya ia adalah kes ujian yang betul: pengendali yang terlatih pada output perbezaan terhingga boleh dijaringkan norm.cdf harga tepat, yang hampir tiada penanda aras FNO dalam kesusasteraan boleh lakukan.

Formulasi FNO

Kami menyusun semula masalah sebagai pembelajaran operator. takrifkan:

• Fungsi input $a(S, t)$: mengekod parameter PDE. Ini boleh termasuk permukaan turun naik $\sigma(S, t)$, fungsi bayaran, dan kadar bebas risiko sebagai saluran yang disusun pada $(S, t)$ grid.
• Fungsi Output $u(S, t) = V(S, t)$: permukaan harga opsyen.

FNO belajar $\mathcal{G}_\theta: a \mapsto u$ daripada set data daripada $(a^{(i)}, u^{(i)})$ pasangan yang dihasilkan oleh penyelesai tradisional. Selepas latihan, inferens untuk sebarang konfigurasi parameter baharu ialah hantaran hadapan tunggal.

Penjanaan Data Latihan

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

Untuk latihan, kami mencuba beribu-ribu konfigurasi parameter — berbeza-beza $\sigma \in [0.05, 0.80]$, $r \in [0.01, 0.10]$, $K \in [50, 150]$, $T \in [0.1, 2.0]$ — dan selesaikan setiap satu dengan kaedah perbezaan terhingga. Dataset yang terhasil bagi pasangan input-output ialah perkara yang FNO pelajari.

Peningkatan: Model Kemeruapan Stokastik Heston

Kemeruapan yang berterusan ialah andaian yang diketahui palsu, dan mengapa ia gagal — senyuman, ekor gemuk — ialah subjek bahagian "Realiti Kejam" The Black-Scholes Formula. Heston membetulkannya dengan menjadikan varians pembolehubah keadaan kedua:

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

dengan $\text{Corr}(dW_1, dW_2) = \rho$. PDE yang sepadan untuk harga opsyen $V(S, v, t)$ adalah dua dimensi dalam ruang:

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

Di sinilah pembelajaran pengendali memperolehnya, dan hujahnya adalah berstruktur dan bukannya empirikal. Skim perbezaan terhingga pada a $(S, v, t)$ skala grid sebagai $O(N_S \times N_v \times N_t)$, istilah terbitan silang $\partial^2 V / \partial S \partial v$ merumitkan pendiskretan, dan setiap set parameter baharu $(\kappa, \theta, \xi, \rho, r)$ membayar kos penuh sekali lagi. Operator membayarnya sekali pada masa latihan. Struktur spatial 2D PDE Heston juga memetakan terus ke FFT 2D dalam lapisan Fourier, jadi seni bina di bawah digeneralisasikan dengan perubahan dimensi dan bukannya reka bentuk semula.

FNO untuk Harga Pilihan: Pelaksanaan PyTorch

Di bawah ialah pelaksanaan FNO lengkap dan serba lengkap untuk mempelajari pengendali Black-Scholes. Seni bina mengikut Li et al. (2021) dengan penyesuaian untuk tetapan kewangan.

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)

Gelung Latihan

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

Inferens: Harga Masa Nyata

@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 lwn PINN: Perbandingan Praktikal

Rangkaian Neural Bermaklumat Fizik dan Operator Neural Fourier mewakili falsafah asas yang berbeza untuk menyelesaikan PDE dengan rangkaian saraf. Memahami pertukaran mereka adalah sebab praktikal untuk mengambil berat tentang pembelajaran pengendali sama sekali.

PINN: Pengoptimuman Setiap Contoh

PINN meletakkan baki PDE secara langsung dalam kerugian — Masalah Navier-Stokes merangkumi mekanisme, autodiff physics_loss pelaksanaan, dan hasil carian ketunggalan DeepMind. Satu-satunya sifat yang penting di sini ialah struktur: PINN dilatih setiap set parameter. Tukar $\sigma$, $r$, $K$ atau $T$ dan anda mengoptimumkan semula dari awal.

Kekuatan: Tiada data berlabel diperlukan. Secara langsung menguatkuasakan struktur PDE. Berfungsi untuk mana-mana PDE yang anda boleh tulis.

Kelemahan: Mesti melatih semula untuk setiap set parameter baharu $(\sigma, r, K, T)$. Latihan melibatkan mengimbangi pelbagai istilah kerugian (sisa PDE, syarat sempadan, keadaan awal) yang sering membawa kepada patologi pengoptimuman. Penumpuan boleh menjadi perlahan — biasanya 10,000–100,000 langkah kecerunan bagi setiap kejadian masalah. Gagal pada sistem berbilang skala dan huru-hara di mana landskap kehilangan menjadi sangat tidak cembung.

FNO: Pembelajaran Operator Dilunaskan

FNO mempelajari pengendali penyelesaian daripada data. Ia memerlukan set data latihan yang dijana oleh penyelesai klasik, tetapi setelah dilatih, ia membuat generalisasi merentas keseluruhan ruang parameter.

Kekuatan: Inferens sub-milisaat dalam penanda aras yang diterbitkan. Mengitlak kepada parameter yang tidak kelihatan tanpa latihan semula. Resolusi-invarian — latih pada resolusi rendah, nilai pada resolusi tinggi. Secara semula jadi mengendalikan penyelesaian PDE yang lancar melalui bias spektrum.

Kelemahan: Memerlukan data latihan daripada penyelesai klasik (masalah ayam-dan-telur untuk PDE yang benar-benar baru). Ralat penghampiran adalah terhad tetapi bukan sifar. Kurang boleh ditafsir daripada pendekatan dikekang PDE. Dan berat sebelah spektrum yang membantu penyelesaian yang lancar adalah liabiliti pada kink hasil.

Perbandingan Kepala-ke-Kepala

Jadual di bawah ialah dilaporkan kesusasteraan, tidak diukur di sini — ketepatan dan baris kelajuan khususnya datang daripada Li et al. (2021) dan kerja susulan pada penanda aras bendalir, bukan daripada penetapan harga pilihan pada perkakasan kami. Baca baris struktur (data yang diperlukan, generalisasi, invarian resolusi) sebagai yang boleh dipercayai.

The Hybrid: Pengendali Neural Bermaklumat Fizik (PINO)

PINO (Li et al., 2024) menggabungkan kedua-dua pendekatan. Ia menggunakan seni bina FNO tetapi menambah kehilangan dipacu data dengan istilah baki PDE:

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

Penguraian adalah bahagian yang berguna. $\mathcal{L}_{\text{data}}$ melabuhkan operator kepada output penyelesai di mana sahaja anda memilikinya; $\lambda \mathcal{L}_{\text{PDE}}$ mengekangnya di mana-mana sahaja anda tidak, termasuk kawasan ruang parameter yang anda tidak pernah sampel. Untuk penetapan harga opsyen, istilah kedua itu menarik atas sebab khusus untuk membiayai: baki PDE ialah kekangan keras, anda juga boleh menilai pada masa inferens sebagai semakan sendiri, yang merupakan asas sandaran pemantauan baki di bawah.

Pertimbangan Praktikal untuk Penggunaan Pengeluaran

Separuh generik ini — belanjawan kependaman inferens, membina saluran paip data, pemantauan untuk hanyut, latihan semula berkala — telah pun diliputi untuk model saraf dalam sistem perdagangan dalam bahagian pengeluaran DeepLOB: Pembelajaran Mendalam mengenai Buku Pesanan Had, dan ia terpakai tidak berubah. Apa yang berikut hanyalah yang khusus untuk pengendali.

Talian Paip Data: Mensampel Ruang Parameter

Menjana data latihan ialah kesesakan utama, dan tidak seperti model data pasaran, anda memilih pengedaran anda sendiri — yang bermaksud anda boleh tersilap dengan cara yang tidak dapat dilihat dalam kerugian. Untuk operator Black-Scholes dengan 4 parameter, 5,000–10,000 sampel sudah memadai. Untuk Heston dengan 5 parameter ditambah domain spatial 2D, 20,000–50,000 sampel adalah tipikal. Gunakan pensampelan adaptif: tumpukan sampel di kawasan parameter di mana penyelesaiannya berubah dengan cepat — hampir-hampir-wang, kematangan pendek, turun naik yang tinggi — kerana pensampelan seragam kotak membelanjakan sebahagian besar belanjawannya pada kawasan deep-ITM dan deep-OTM di mana pengendalinya hampir linear dan belajar dengan baik daripada beberapa contoh.

Penalaan Seni Bina

• Mod ($k_{\max}$): Mulakan dengan $N/4$ di mana $N$ ialah saiz grid spatial. Untuk $N=256$, gunakan 32–64 mod. Terlalu sedikit mod kehilangan butiran berhampiran sempadan mogok; terlalu banyak overfit kepada bunyi bising.
• Lapisan: 4 lapisan Fourier adalah standard. Rangkaian yang lebih dalam (6–8) membantu untuk masalah 2D seperti Heston tetapi meningkatkan ingatan.
• Saluran tersembunyi: 64 untuk 1D Black-Scholes, 128 untuk 2D Heston. Skala dengan kerumitan masalah.

Ketepatan: Soalan fp32

SpectralConv1d memperuntukkan torch.cfloat — kompleks ketepatan tunggal — dan setiap perjalanan pergi balik FFT berjalan pada ketepatan itu. Blog ini telah pun menonton saluran paip kewangan fp32 yang mengembalikan sampah senyap dalam The GPU Precision Trap, di mana rumusan jumlah awalan yang betul secara matematik hilang dengan teruk pada magnitud fp32. Soalan analog di sini adalah langsung: di $S \approx 100$ dengan harga yang disebut kepada sen, adakah perjalanan pergi-balik spektrum fp32 berpegang kepada $10^{-2}$ mutlak, atau adakah pertumbuhan magnitud perantaraan FFT memakan digit bererti terakhir?

Kawalan Ralat

Untuk penetapan harga pilihan pengeluaran, anda memerlukan had ralat yang boleh anda pertahankan.

1. Ketidakpastian yang ditentukur: sisihan piawai ensemble ialah bukan jaminan liputan, dan blog ini mempunyai jentera untuk melakukannya dengan betul — berpecah konformal ke atas grid parameter yang ditahan, dengan ACI/DtACI untuk kes tidak boleh tukar, dalam Ramalan Konformal untuk Pengukuran Kedudukan Sedar Risiko. Membungkus FNO dalam konformal berpecah di atas $(\sigma, r, K, T)$ grid memberikan selang bebas pengagihan pada harga.
2. Pemantauan baki: Kira baki PDE ramalan FNO sebagai semakan post-hoc. Jika $\|\text{residual}\| > \epsilon$, kembali kepada penyelesai klasik. Ini adalah percuma pada inferens — baki ialah stensil perbezaan terhingga pada tatasusunan yang sudah anda miliki.
3. Pembelajaran aktif: Halakan input ketidakpastian tinggi kepada penyelesai klasik, tambahkan hasil pada set latihan dan latih semula secara berkala. Lebar selang konformal dari (1) ialah isyarat penghalaan semula jadi.

Agenda Pengukuran

Ini adalah bahagian yang menentukan sama ada seni bina di atas berbaloi untuk digunakan, dan masih belum selesai. Ia disenaraikan di sini dan bukannya dikuburkan kerana alternatif — menegaskan mempercepatkan tajuk berita — adalah tepat daftar blog ini wujud untuk dielakkan.

1. Kelajuan ialah lengkung, bukan nombor. Apabila GPU Berbayar menetapkan bentuk: $S(B) = aB/(O + bB)$, meningkat daripada overhed didominasi pada $B=1$ ke dataran tinggi terikat pengiraan, dan ia menunjukkan tajuk 167x terurai menjadi 27x algoritma darab 6.2x perkakasan. Pengukuran FNO mesti mengikut templat itu: jam dinding pas ke hadapan di $B \in \{1, 8, 64, 512\}$ dan laporkan keseluruhan lengkung. Secara kritis, garis dasar mestilah penyelesai perbezaan terhingga vektor, berbilang teras — black_scholes_fd di atas ialah gelung berganda yang ditafsirkan, garis dasar "pelaksanaan CPU terburuk" yang tepat yang diberi nama artikel, dan membandingkan pengendali GPU berkumpulan dengannya akan menghasilkan nombor yang tidak bermakna.

2. Ketepatan terhadap bentuk tertutup. Ini adalah percubaan Black-Scholes yang dibuat hampir percuma dan penanda aras dinamik bendalir tidak dapat dilakukan sama sekali: melatih data yang dijana FD, kemudian menjaringkan skor terhadap tepat norm.cdf harga di seluruh $(\sigma, r, K, T)$ kotak. Laporkan saudara $L^2$, dan laporkan ralat pengedaran — khususnya berhampiran mogok dan hampir tamat tempoh, di mana penyelesaiannya paling tidak lancar dan asas spektrum terpenggal harus paling sukar.

3. Pelanggaran tanpa arbitraj. Pengendali terpelajar tidak mempunyai sebab struktur untuk menghormati kekangan bentuk yang mesti dipenuhi oleh permukaan harga: monotonisitas dalam $K$, cembung dalam $K$, dan $V \geq \max(S-K, 0)$. Mengukur kadar pelanggaran merentas kotak parameter mengubah soalan terbuka artikel ini sendiri — bolehkah kami menjamin keadaan tanpa timbang tara dalam operator yang dipelajari? — daripada melambai tangan kepada nombor.

4. Invarian pendiskretan, diuji dan bukannya ditegaskan. Latih di $N_S = 128$, menilai di $N_S = 512$, laporkan ralat. Mod kegagalan yang dijangkakan diberi nama dan khusus: Gibbs berdering di kink $\max(S-K, 0)$. Asas Fourier terpenggal yang membina semula fungsi dengan terbitan pertama terputus berayun di sekelilingnya, dan resolusi super tangkapan sifar boleh menjadikannya lebih buruk daripada lebih baik dengan mendedahkan mod yang tidak pernah dilihat resolusi latihan. Jika resolusi super merosot berhampiran mogok, hasil negatif itu lebih berharga daripada tuntutan pemasaran yang digantikannya — tiada siapa dalam literatur FNO yang menetapkan harga pilihan dengan kekusutan hasil.

Jika percubaan 1–4 tidak boleh dijalankan, artikel ini tidak sepatutnya dihantar. Apa yang kekal tanpa mereka ialah eksposisi kertas ICLR orang lain yang ditulis dengan baik.

Melangkaui Pilihan Vanila

Dengan mengandaikan agenda di atas kekal bersentuhan dengan pengukuran, rangka kerja FNO meluas secara semula jadi kepada instrumen yang lebih kompleks:

• Pilihan Amerika: Tambahkan sempadan latihan awal sebagai saluran keluaran tambahan. FNO mempelajari kedua-dua permukaan harga dan sempadan latihan optimum secara serentak.
• Pilihan halangan: Mengekodkan tahap halangan sebagai saluran input. Ambil perhatian bahawa halangan ialah ketakselanjaran kedua, dan kebimbangan Gibbs daripada agenda pengukuran digunakan dengan lebih kuat, bukan kurang.
• Bakul berbilang aset: Gunakan FNO 2D atau 3D untuk pilihan bakul pada 2–3 asas. Sumpahan dimensi adalah kurang teruk berbanding penyelesai berasaskan grid kerana FNO beroperasi pada bilangan mod tetap.
• Kemeruapan tempatan: Masukkan permukaan turun naik tempatan Dupire penuh $\sigma_{\text{loc}}(S,t)$ sebagai fungsi spatial. Ini adalah kes penggunaan paling semula jadi untuk pembelajaran operator — input adalah fungsi, bukan parameter skalar.

Kesimpulan

Sumbangan Operator Neural Fourier adalah konseptual sebelum ia dikira: daripada menyelesaikan satu PDE pada satu masa, anda menetapkan parameter pengendali penyelesaian itu sendiri, dan melakukan itu dalam ruang Fourier menghasilkan seni bina yang $O(n \log n)$, universal pada pengendali berterusan, dan resolusi-fleksibel dengan pembinaan. Itu banyak mengikuti daripada Li et al. (2021) dan daripada kod di atas, yang dijalankan.

Apa yang tidak diikuti ialah nombor percepatan. Angka 100x–1000x literatur diukur pada penanda aras bendalir terhadap garis dasar yang kualitinya jarang dinyatakan, dan siri ini telah menghabiskan keseluruhan artikel yang menunjukkan jumlah tajuk sedemikian biasanya algoritma dan bukannya perkakasan. Dakwaan yang mewajarkan meletakkan operator dalam enjin penentuan harga — ketepatan fp32 tahap sen, kadar pelanggaran tanpa timbang tara yang terhad, resolusi super yang bertahan daripada kekusutan imbuhan dan keluk mempercepatkan terhadap penyelesai CPU cekap — semuanya boleh diukur, semuanya murah di Black-Scholes kerana bentuk tertutup wujud dan semuanya masih tidak diukur.

Itulah keadaan draf ini: mekanismenya adalah nyata, janji itu munasabah, dan bukti belum selesai.

Rujukan dan bacaan lanjut:

• Li, Z., Kovachki, N., Azizzadenesheli, K., et al. "Fourier Neural Operator untuk Persamaan Pembezaan Separa Parametrik." ICLR 2021. arXiv:2010.08895
• Lu, L., Jin, P., Pang, G., Zhang, Z., & Karniadakis, G.E. "Mempelajari pengendali bukan linear melalui DeepONet." Perisikan Mesin Alam, 2021. doi:10.1038/s42256-021-00302-5
• Li, Z., et al. "Operator Neural Bermaklumat Fizik untuk Mempelajari Persamaan Pembezaan Separa." Jurnal Sains Data ACM/IMS, 2024. OpenReview
• neuraloperator Pustaka PyTorch: github.com/neuraloperator/neuraloperator
• Salvador, M., et al. "Pembelajaran Rangkaian Neural Persamaan Black-Scholes untuk Harga Opsyen." arXiv:2405.05780
• Bai, Y., et al. "The AI ​​Black-Scholes: Rangkaian Neural Bermaklumat Kewangan." arXiv:2412.12213