Operator Neural Fourier untuk Pemodelan Keuangan Berbasis PDE

Setiap jaringan saraf di blog ini sejauh ini telah memperkirakan fungsi: fitur masuk, nomor keluar. Operator Neural Fourier memperkirakan sebuah operator — peta antara ruang fungsi berdimensi tak terhingga, dengan masukan berupa seluruh permukaan volatilitas dan keluaran berupa seluruh permukaan harga. Itu adalah objek yang berbeda, memerlukan mesin yang berbeda, dan mesin tersebut adalah inti dari artikel ini: kernel bernilai kompleks yang dapat dipelajari yang diterapkan pada mode Fourier terendah, dievaluasi melalui perjalanan bolak-balik FFT dalam $O(n \log n)$.

Penetapan harga opsi adalah tempat di mana hal ini terjadi di bidang keuangan. Black-Scholes, Heston, volatilitas lokal — semua PDE, semuanya diselesaikan hari ini dengan satu set parameter pada satu waktu. Operator mempelajari seluruh kelompok parameter sekaligus, dan forward pass yang dihasilkan adalah kernel GPU batch tunggal, bukan loop time-marching.

Itulah janjinya. Versi jujur ​​dari artikel ini memisahkan mekanisme, yang solid dan dapat direproduksi dari kode di bawah, dari klaim kinerja, yang dalam literatur FNO dilaporkan berdasarkan garis dasar yang tidak akan diterima oleh siapa pun di seri ini jika tidak diperiksa. Mekaniknya diutamakan; agenda pengukuran muncul di bagian akhir, ditandai sebagai belum dijalankan.

Dari Pendekatan Fungsi hingga Pembelajaran Operator

Fungsi perkiraan jaringan saraf klasik: diberi masukan $x \in \mathbb{R}^n$, mereka menghasilkan keluaran $y \in \mathbb{R}^m$. Hal ini sangat kuat, namun pada dasarnya terbatas jika objek yang diteliti adalah fungsinya sendiri. Dalam penyelesaian PDE finansial, masukannya bukanlah angka tunggal — melainkan fungsi yang menggambarkan kondisi awal/batas, permukaan volatilitas, atau struktur istilah. Outputnya memiliki fungsi lain: harga muncul ke permukaan $(S, t)$ ruang angkasa.

Pembelajaran operator mengangkat masalah ke ruang berdimensi tak terbatas. Daripada belajar $f: \mathbb{R}^n \to \mathbb{R}^m$, kita mempelajari operator:

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

Di mana $\mathcal{A}$ Dan $\mathcal{U}$ adalah ruang fungsi Banach. Untuk penetapan harga opsi, $\mathcal{A}$ mungkin merupakan ruang permukaan volatilitas $\sigma(S,t)$ Dan $\mathcal{U}$ ruang permukaan harga yang sesuai $V(S,t)$.

Dua arsitektur mendominasi lanskap pembelajaran operator:

1. DeepONet (Lu et al., 2021): Menggunakan jaringan cabang untuk mengkodekan fungsi input dan jaringan trunk untuk mengkodekan lokasi kueri. Outputnya adalah produk dalam mereka. Didasarkan pada teorema pendekatan universal untuk operator oleh Chen dan Chen (1995).

2. Fourier Neural Operator (Li et al., 2021): Membuat parameter kernel integral dalam ruang Fourier, menggunakan FFT untuk konvolusi global yang efisien. Resolusi-invarian berdasarkan konstruksi.

Keduanya merupakan perkiraan universal untuk operator kontinu, namun FNO memiliki keunggulan struktural untuk masalah PDE: bias spektralnya secara alami mencerminkan struktur global solusi PDE yang mulus. Hal ini juga memiliki kerugian struktural khususnya untuk pembayaran opsi, yang akan kita bahas lagi - basis Fourier yang terpotong dan kekusutan dalam pemogokan bukanlah sekutu alami.

Arsitektur FNO secara Detail

Operator Neural Fourier, diperkenalkan oleh Li et al. di ICLR 2021, dibangun berdasarkan observasi sederhana namun kuat: fungsi Green (kernel integral) dari banyak PDE memiliki representasi kompak dalam ruang Fourier. Daripada mempelajari kernel di ruang fisik - yang memerlukan $O(n^2)$ parameter untuk $n$ titik grid - FNO mempelajarinya dalam ruang frekuensi dengan hanya yang terendah $k_{\max}$ mode, mengurangi kompleksitas menjadi $O(n \log n)$ melalui FFT.

Arsitektur Iteratif

FNO terdiri dari:

1.Lapisan pengangkat $P$: Peta linier runcing yang memproyeksikan masukan dari dimensi saluran aslinya ke representasi laten berdimensi lebih tinggi: $v_0(x) = P(a(x))$.

2. Lapisan empat lapis (berulang $L$ kali): Setiap lapisan berlaku:

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

Di mana $W_l$ adalah transformasi linier lokal (searah $1 \times 1$ konvolusi) dan $\mathcal{K}_l$ adalah operator integral global yang diimplementasikan 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}$ menunjukkan FFT, $R_l$ adalah tensor bobot bernilai kompleks yang dapat dipelajari yang diterapkan pada nilai terendah $k_{\max}$ Mode Fourier, dan $\sigma$ adalah aktivasi nonlinier yang tepat sasaran (biasanya GELU).

3. Lapisan proyeksi $Q$: Memetakan representasi laten kembali ke dimensi keluaran: $u(x) = Q(v_L(x))$.

Mengapa Ruang Fourier?

Konvolusi spektral $R_l \cdot \mathcal{F}(v_l)$ adalah perkalian dalam domain frekuensi, yang setara dengan konvolusi global dalam ruang fisik — tetapi dihitung dalam $O(n \log n)$ alih-alih $O(n^2)$. Ini bukan sekadar trik efisiensi. Solusi PDE biasanya mulus dan didominasi oleh komponen frekuensi rendah. Dengan memotong ke $k_{\max}$ mode, FNO bertindak sebagai filter low-pass yang dapat dipelajari yang secara alami mengatur solusi dan menghindari artefak frekuensi tinggi.

Yang terpenting, FNO diklaim invarian-diskretisasi: setelah dilatih pada grid ukuran $n$, itu dapat dievaluasi pada resolusi apa pun $m \neq n$ hanya dengan menyesuaikan ukuran FFT dan zero-padding atau memotong bobot spektral. Properti resolusi super zero-shot ini unik di antara pemecah PDE saraf — dan ini adalah klaim pertama dalam artikel ini yang layak untuk diukur, bukan dikutip. Lihat agenda pengukuran di bawah ini.

PDE Yang Kami Pelajari Operatornya

PDE Black-Scholes — yang diturunkan, dibedah istilah demi istilah, dan diberikan dengan solusi call/put bentuk tertutupnya dalam Formula Black-Scholes — adalah target operator:

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

Segala sesuatu yang berikut ini memperlakukannya sebagai kotak hitam dengan jawaban yang diketahui. Jawaban yang diketahui itulah yang menjadi alasan mengapa ini merupakan kasus uji yang tepat: operator yang dilatih tentang keluaran perbedaan hingga dapat diberi skor terhadap norm.cdf harga pastinya, yang hampir tidak dapat dilakukan oleh tolok ukur FNO dalam literatur.

Formulasi FNO

Kami menyusun kembali masalah ini sebagai pembelajaran operator. Definisikan:

• Fungsi masukan $a(S, t)$: mengkodekan parameter PDE. Hal ini dapat mencakup permukaan volatilitas $\sigma(S, t)$, fungsi pembayaran, dan tarif bebas risiko saat saluran ditumpuk di $(S, t)$ jaringan.
• Fungsi keluaran $u(S, t) = V(S, t)$: permukaan harga opsi.

FNO belajar $\mathcal{G}_\theta: a \mapsto u$ dari kumpulan data $(a^{(i)}, u^{(i)})$ pasangan yang dihasilkan oleh pemecah tradisional. Setelah pelatihan, inferensi untuk setiap konfigurasi parameter baru adalah satu forward pass.

Pelatihan Pembuatan Data

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 pelatihan, kami mengambil sampel ribuan konfigurasi parameter — bervariasi $\sigma \in [0.05, 0.80]$, $r \in [0.01, 0.10]$, $K \in [50, 150]$, $T \in [0.1, 2.0]$ — dan selesaikan masing-masing dengan metode beda hingga. Kumpulan data pasangan input-output yang dihasilkan inilah yang dipelajari oleh FNO.

Peningkatan: Model Volatilitas Stokastik Heston

Volatilitas konstan adalah asumsi yang diketahui salah, dan mengapa hal ini gagal — senyuman, ekor gemuk — adalah subjek dari bagian "Realitas Keras" di Formula Black-Scholes. Heston memperbaikinya dengan menjadikan varians sebagai variabel 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 sesuai untuk harga opsi $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 operator berperan, dan argumennya bersifat struktural, bukan empiris. Skema beda hingga pada a $(S, v, t)$ skala grid sebagai $O(N_S \times N_v \times N_t)$, istilah turunan silang $\partial^2 V / \partial S \partial v$ mempersulit diskritisasi, dan setiap parameter baru ditetapkan $(\kappa, \theta, \xi, \rho, r)$ membayar biaya penuh lagi. Operator membayarnya satu kali pada waktu pelatihan. Struktur spasial 2D dari Heston PDE juga dipetakan langsung ke FFT 2D di lapisan Fourier, sehingga arsitektur di bawah ini digeneralisasikan dengan perubahan dimensi daripada desain ulang.

FNO untuk Penetapan Harga Opsi: Implementasi PyTorch

Di bawah ini adalah implementasi FNO mandiri yang lengkap untuk mempelajari operator Black-Scholes. Arsitekturnya mengikuti Li et al. (2021) dengan adaptasi kondisi keuangan.

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)

Lingkaran 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

Inferensi: Penetapan Harga Waktu 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 vs. PINN: Perbandingan Praktis

Jaringan Neural Berinformasi Fisika dan Operator Neural Fourier mewakili filosofi yang berbeda secara mendasar untuk menyelesaikan PDE dengan jaringan saraf. Memahami trade-off mereka adalah alasan praktis untuk peduli terhadap pembelajaran operator.

PINN: Optimasi Per Instance

PINN menyebabkan sisa PDE langsung hilang — Masalah Navier-Stokes meliputi mekanisme, autodiff physics_loss implementasi, dan hasil pencarian singularitas DeepMind. Satu-satunya properti yang penting di sini adalah struktural: PINN dilatih per set parameter. Ubah $\sigma$, $r$, $K$ atau $T$ dan Anda mengoptimalkan lagi dari awal.

Kelebihan: Tidak diperlukan data berlabel. Secara langsung menegakkan struktur PDE. Berfungsi untuk PDE apa pun yang dapat Anda tulis.

Kelemahan: Harus berlatih ulang untuk setiap set parameter baru $(\sigma, r, K, T)$. Pelatihan melibatkan penyeimbangan beberapa istilah kerugian (sisa PDE, kondisi batas, kondisi awal) yang sering kali mengarah pada patologi optimasi. Konvergensi bisa lambat — biasanya 10.000–100.000 langkah gradien per contoh masalah. Gagal pada sistem multi-skala dan chaos dimana lanskap kerugian menjadi sangat non-cembung.

FNO: Pembelajaran Operator yang Diamortisasi

FNO mempelajari operator solusi dari data. Hal ini memerlukan kumpulan data pelatihan yang dihasilkan oleh pemecah klasik, tetapi setelah dilatih, data tersebut akan digeneralisasi ke seluruh ruang parameter.

Kekuatan: Inferensi sub-milidetik dalam tolok ukur yang dipublikasikan. Generalisasi ke parameter yang tidak terlihat tanpa pelatihan ulang. Resolusi-invarian - latih dengan resolusi rendah, evaluasi dengan resolusi tinggi. Secara alami menangani solusi PDE yang mulus melalui bias spektral.

Kelemahan: Memerlukan data pelatihan dari pemecah masalah klasik (masalah ayam-dan-telur untuk PDE yang benar-benar baru). Kesalahan perkiraan dibatasi tetapi bukan nol. Kurang dapat ditafsirkan dibandingkan pendekatan yang dibatasi PDE. Dan bias spektral yang membantu kelancaran solusi adalah sebuah tanggung jawab dalam masalah hasil.

Perbandingan Head-to-Head

Tabel di bawah ini dilaporkan dari literatur, tidak diukur di sini — baris akurasi dan kecepatan khususnya berasal dari Li dkk. (2021) dan pekerjaan tindak lanjut pada tolok ukur yang lancar, bukan dari penetapan harga opsi pada perangkat keras kami. Baca baris struktural (data yang diperlukan, generalisasi, invarian resolusi) sebagai baris yang dapat diandalkan.

Hibrida: Operator Neural Berinformasi Fisika (PINO)

PINO (Li et al., 2024) menggabungkan kedua pendekatan tersebut. Ia menggunakan arsitektur FNO tetapi menambah kerugian berdasarkan data dengan istilah sisa PDE:

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

Dekomposisi adalah bagian yang berguna. $\mathcal{L}_{\text{data}}$ mengaitkan operator ke keluaran pemecah di mana pun Anda memilikinya; $\lambda \mathcal{L}_{\text{PDE}}$ membatasinya di mana pun Anda tidak melakukannya, termasuk wilayah ruang parameter yang tidak pernah Anda sampel. Untuk penetapan harga opsi, istilah kedua ini menarik karena alasan khusus untuk keuangan: sisa PDE adalah kendala sulit yang juga dapat Anda evaluasi pada waktu inferensi sebagai pemeriksaan mandiri, yang merupakan dasar dari fallback pemantauan sisa di bawah ini.

Pertimbangan Praktis untuk Penerapan Produksi

Setengah dari hal ini — anggaran latensi inferensi, pembuatan pipeline data, pemantauan penyimpangan, pelatihan ulang berkala — sudah tercakup dalam model neural dalam sistem perdagangan di bagian produksi DeepLOB: Deep Learning on Limit Order Books, dan ini berlaku tanpa perubahan. Berikut ini hanyalah yang khusus untuk suatu operator.

Saluran Data: Mengambil Sampel Ruang Parameter

Menghasilkan data pelatihan adalah hambatan utama, dan tidak seperti model data pasar, Anda memilih distribusi Anda sendiri — yang berarti Anda bisa melakukan kesalahan dengan cara yang tidak terlihat dalam kerugian. Untuk operator Black-Scholes dengan 4 parameter, 5.000–10.000 sampel sudah cukup. Untuk Heston dengan 5 parameter ditambah domain spasial 2D, biasanya terdapat 20.000–50.000 sampel. Gunakan pengambilan sampel adaptif: konsentrasikan sampel di wilayah parameter di mana solusinya bervariasi dengan cepat — hampir menghasilkan uang, jatuh tempo pendek, volatilitas tinggi — karena pengambilan sampel yang seragam menghabiskan sebagian besar anggarannya di wilayah deep-ITM dan deep-OTM di mana operatornya hampir linier dan belajar dengan baik dari sangat sedikit contoh.

Penyetelan Arsitektur

• Mode ($k_{\max}$): Mulailah dengan $N/4$ Di mana $N$ adalah ukuran grid spasial. Untuk $N=256$, gunakan 32–64 mode. Terlalu sedikit moda yang kehilangan detail di dekat batas serangan; terlalu banyak pakaian yang menimbulkan kebisingan.
• Lapisan: 4 lapisan Fourier adalah standar. Jaringan yang lebih dalam (6–8) membantu mengatasi masalah 2D seperti Heston tetapi meningkatkan memori.
• Saluran tersembunyi: 64 untuk 1D Black-Scholes, 128 untuk 2D Heston. Skala dengan kompleksitas masalah.

Presisi: Pertanyaan fp32

SpectralConv1d mengalokasikan torch.cfloat — kompleks dengan presisi tunggal — dan setiap perjalanan pulang pergi FFT berjalan dengan presisi tersebut. Blog ini telah melihat saluran keuangan fp32 mengembalikan sampah diam-diam di The GPU Precision Trap, yang mana formulasi jumlah awalan yang benar secara matematis hilang secara drastis pada besaran fp32. Pertanyaan analoginya di sini adalah langsung: di $S \approx 100$ dengan harga yang dikutip dalam sen, apakah perjalanan pulang pergi spektral fp32 berlaku $10^{-2}$ mutlak, atau apakah pertumbuhan besaran menengah FFT memakan angka signifikan terakhir?

Kontrol Kesalahan

Untuk penetapan harga opsi produksi, Anda memerlukan batasan kesalahan yang dapat dipertahankan.

1. Ketidakpastian yang dikalibrasi: deviasi standar ansambel bukan jaminan cakupan, dan blog ini memiliki mesin untuk melakukannya dengan benar — membagi konformal pada kisi parameter yang ditahan, dengan ACI/DtACI untuk kasus yang tidak dapat ditukar, di Prediksi Konformal untuk Ukuran Posisi Sadar Risiko. Membungkus FNO dengan konformal terpisah di atasnya $(\sigma, r, K, T)$ grid memberikan interval bebas distribusi pada harga.
2. Pemantauan sisa: Hitung sisa PDE dari prediksi FNO sebagai pemeriksaan post-hoc. Jika $\|\text{residual}\| > \epsilon$, kembali ke pemecah klasik. Ini bebas dalam inferensi - residunya adalah stensil perbedaan hingga pada array yang sudah Anda miliki.
3. Pembelajaran aktif: Arahkan masukan dengan ketidakpastian tinggi ke pemecah klasik, tambahkan hasilnya ke set pelatihan, dan latih ulang secara berkala. Lebar interval konformal dari (1) adalah sinyal routing alami.

Agenda Pengukuran

Ini adalah bagian yang menentukan apakah arsitektur di atas layak untuk diterapkan, dan belum ada satupun yang selesai. Ini dicantumkan di sini daripada dikuburkan karena alternatifnya — menegaskan percepatan judul — justru merupakan daftar yang harus dihindari oleh blog ini.

1. Percepatan adalah sebuah kurva, bukan angka. Saat GPU Terbayar menentukan bentuknya: $S(B) = aB/(O + bB)$, naik dari didominasi overhead di $B=1$ ke dataran tinggi yang terikat komputasi, dan ini menunjukkan judul 167x yang didekomposisi menjadi 27x algoritme dikalikan 6,2x perangkat keras. Pengukuran FNO harus mengikuti pola berikut: jam dinding pada lintasan maju $B \in \{1, 8, 64, 512\}$ dan laporkan seluruh kurva. Yang terpenting, garis dasar harus berupa pemecah perbedaan hingga tervektorisasi, multi-inti - black_scholes_fd di atas adalah loop ganda yang ditafsirkan, garis dasar "implementasi CPU terburuk" yang diberi nama artikel, dan membandingkan operator GPU batch dengan operator tersebut akan menghasilkan angka yang tidak berarti apa-apa.

2. Akurasi dibandingkan dengan bentuk tertutup. Ini adalah eksperimen yang dibuat Black-Scholes hampir bebas dan yang tidak dapat dilakukan oleh tolok ukur dinamika fluida sama sekali: berlatih berdasarkan data yang dihasilkan FD, lalu mencetak skor berdasarkan data yang tepat norm.cdf harga di seluruh $(\sigma, r, K, T)$ kotak. Laporkan kerabatnya $L^2$, dan laporkan kesalahan distribusi — khususnya menjelang pemogokan dan hampir habis masa berlakunya, di mana solusinya paling tidak mulus dan basis spektral yang terpotong akan mengalami kesulitan yang paling besar.

3. Tidak ada pelanggaran arbitrase. Operator yang terpelajar tidak memiliki alasan struktural untuk menghormati batasan bentuk yang harus dipenuhi oleh permukaan harga: monotonisitas dalam $K$, konveksitas dalam $K$, Dan $V \geq \max(S-K, 0)$. Mengukur tingkat pelanggaran di seluruh kotak parameter mengubah pertanyaan terbuka artikel ini — bisakah kami menjamin kondisi tanpa arbitrase di operator yang terpelajar? — dari lambaian tangan menjadi angka.

4. Invariansi diskritisasi, diuji, bukan ditegaskan. Latih di $N_S = 128$, evaluasi di $N_S = 512$, laporkan kesalahannya. Mode kegagalan yang diharapkan diberi nama dan spesifik: Gibbs berdering di kink $\max(S-K, 0)$. Basis Fourier terpotong yang merekonstruksi suatu fungsi dengan turunan pertama yang terputus-putus berosilasi di sekitarnya, dan resolusi super zero-shot dapat memperburuk keadaan dengan mengekspos mode yang tidak pernah dilihat oleh resolusi pelatihan. Jika resolusi super menurun menjelang pemogokan, hasil negatif tersebut akan lebih berharga dibandingkan klaim pemasaran yang digantikannya – tidak ada seorang pun dalam literatur FNO yang menetapkan harga opsi dengan imbalan yang tidak wajar.

Jika eksperimen 1–4 tidak dapat dijalankan, artikel ini tidak boleh dikirimkan. Yang tersisa tanpa mereka hanyalah eksposisi makalah ICLR orang lain yang ditulis dengan baik.

Selain Pilihan Vanila

Dengan asumsi agenda di atas tetap berhubungan dengan pengukuran, kerangka FNO secara alami meluas ke instrumen yang lebih kompleks:

• Opsi Amerika: Tambahkan batas latihan awal sebagai saluran keluaran tambahan. FNO mempelajari permukaan harga dan batas latihan optimal secara bersamaan.
• Opsi penghalang: Mengkodekan tingkat penghalang sebagai saluran masukan. Perhatikan bahwa hambatan adalah diskontinuitas kedua, dan kekhawatiran Gibbs dalam agenda pengukuran berlaku dengan kekuatan yang lebih besar, bukan lebih kecil.
• Keranjang multi-aset: Gunakan FNO 2D atau 3D untuk opsi keranjang pada 2–3 aset dasar. Kutukan dimensi tidak terlalu parah dibandingkan pemecah berbasis grid karena FNO beroperasi pada sejumlah mode yang tetap.
• Volabilitas lokal: Masukkan permukaan volatilitas lokal Dupire secara lengkap $\sigma_{\text{loc}}(S,t)$ sebagai fungsi spasial. Ini adalah kasus penggunaan paling alami untuk pembelajaran operator — inputnya adalah sebuah fungsi, bukan parameter skalar.

Kesimpulan

Kontribusi Operator Neural Fourier bersifat konseptual sebelum bersifat komputasi: alih-alih menyelesaikan satu PDE dalam satu waktu, Anda membuat parameter pada operator solusi itu sendiri, dan melakukan hal tersebut dalam ruang Fourier akan menghasilkan arsitektur yang $O(n \log n)$, universal pada operator berkelanjutan, dan resolusi-fleksibel berdasarkan konstruksi. Hal ini mengikuti dari Li dkk. (2021) dan dari kode di atas yang dijalankan.

Yang tidak mengikuti adalah nomor percepatan. Angka 100x–1000x dalam literatur diukur berdasarkan tolok ukur yang lancar terhadap garis dasar yang kualitasnya jarang dinyatakan, dan seri ini telah menghabiskan seluruh artikel yang menunjukkan seberapa banyak judul tersebut biasanya berupa algoritma, bukan perangkat keras. Klaim yang akan membenarkan menempatkan operator dalam mesin penetapan harga — akurasi fp32 tingkat sen, tingkat pelanggaran tanpa arbitrase yang terbatas, resolusi super yang bertahan dalam masalah pembayaran, dan kurva percepatan terhadap pemecah CPU yang kompeten — semuanya dapat diukur, semuanya murah di Black-Scholes karena bentuk tertutupnya ada, dan semuanya masih belum terukur di sini.

Demikian isi rancangan ini: mekanismenya nyata, janjinya masuk akal, dan buktinya masih menunggu.

Referensi dan bacaan lebih lanjut:

• Li, Z., Kovachki, N., Azizzadenesheli, K., dkk. "Operator Saraf Fourier untuk Persamaan Diferensial Parsial Parametrik." ICLR 2021. arXiv:2010.08895
• Lu, L., Jin, P., Pang, G., Zhang, Z., & Karniadakis, GE. "Mempelajari operator nonlinier melalui DeepONet." Kecerdasan Mesin Alam, 2021. doi:10.1038/s42256-021-00302-5
• Li, Z., dkk. "Operator Syaraf Berpengetahuan Fisika untuk Mempelajari Persamaan Diferensial Parsial." Jurnal Ilmu Data ACM/IMS, 2024. OpenReview
• neuraloperator Perpustakaan PyTorch: github.com/neuraloperator/neuraloperator
• Salvador, M., dkk. "Pembelajaran Jaringan Saraf Persamaan Black-Scholes untuk Penetapan Harga Opsi." arXiv:2405.05780
• Bai, Y., dkk. "AI Black-Scholes: Jaringan Neural yang Diinformasikan Keuangan." arXiv:2412.12213