PDE-ga asoslangan moliyaviy modellashtirish uchun Furye neyron operatori

Ushbu blogdagi har bir neyron tarmog'i hozirgacha funksiyaga yaqinlashgan: xususiyatlar kirish, raqam chiqish. Furye neyrooperatori **operatorga ** yaqinlashadi - cheksiz o'lchamli funktsiyalar bo'shliqlari orasidagi xarita, bu erda kirish butun o'zgaruvchanlik yuzasi va chiqish butun narx yuzasidir. Bu boshqa ob'ekt, unga turli xil mashinalar kerak va mashina ushbu maqolaning mohiyatidir: FFT bo'ylab sayohat orqali baholanadigan eng past Furye rejimlarida qo'llaniladigan o'rganish mumkin bo'lgan murakkab qiymatli yadro. $O(n \log n)$.

Opsion narxlash - bu moliyaga tushadigan joy. Blek-Skoulz, Heston, mahalliy o'zgaruvchanlik - barcha PDElar, bugungi kunda barchasi bir vaqtning o'zida bitta parametr to'plamini hal qildi. Operator bir vaqtning o'zida butun parametrlar oilasini o'rganadi va natijada oldinga o'tish vaqt oralig'idagi tsikl emas, balki bitta paketli GPU yadrosidir.

Bu va'da. Ushbu maqolaning halol versiyasi quyidagi koddan mustahkam va takrorlanishi mumkin bo'lgan mexanikani, FNO adabiyotida ushbu seriyadagi hech kim o'rganilmagan holda qabul qilmaydigan asosiy ko'rsatkichlarga nisbatan bildirilgan ishlash da'volaridan ajratadi. Mexanika birinchi o'rinda turadi; o'lchov kun tartibi oxirida keladi, bajarilmagan deb belgilangan.

Funksiyani yaqinlashtirishdan operatorni o'rganishgacha

Klassik neyron tarmoqlar taxminiy funktsiyalar: kirish berilgan $x \in \mathbb{R}^n$, ular mahsulot ishlab chiqaradi $y \in \mathbb{R}^m$. Bu juda kuchli, ammo qiziqish ob'ektlarining o'zi funktsiyalari bo'lganda tubdan cheklangan. Moliyaviy PDE ni hal qilishda kirish bitta raqam emas - bu boshlang'ich/chegara shartlarini, o'zgaruvchanlik yuzasini yoki atama tuzilishini tavsiflovchi funktsiyadir. Chiqarish boshqa funktsiyadir: narx yuzasi $(S, t)$ bo'sh joy.

Operatorni o'rganish muammoni cheksiz o'lchamli bo'shliqlarga ko'taradi. O'rganish o'rniga $f: \mathbb{R}^n \to \mathbb{R}^m$, biz operatorni o'rganamiz:

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

qayerda $\mathcal{A}$ va $\mathcal{U}$ funksiyalarning Banax fazolaridir. Variant narxlari uchun, $\mathcal{A}$ uchuvchanlik yuzalarining maydoni bo'lishi mumkin $\sigma(S,t)$ va $\mathcal{U}$ mos keladigan narx sirtlarining maydoni $V(S,t)$.

Operatorni o'rganish landshaftida ikkita arxitektura ustunlik qiladi:

1. DeepONet (Lu va boshq., 2021): Kirish funktsiyasini kodlash uchun filial tarmog'idan va so'rovlar joylashuvini kodlash uchun magistral tarmoqdan foydalanadi. Chiqarish ularning ichki mahsulotidir. Chen va Chen (1995) tomonidan operatorlar uchun universal yaqinlashish teoremasiga asoslanadi.

2. Fourier Neyron Operator (Li va boshq., 2021): Samarali global konvolyutsiya uchun FFT dan foydalangan holda Furye fazosida integral yadro parametrlarini belgilaydi. Rezolyutsiya qurilishi bo'yicha o'zgarmas.

Ikkalasi ham uzluksiz operatorlar uchun universal yaqinlashuvchidir, lekin FNO PDE muammolari uchun tizimli afzalliklarga ega: uning spektral moyilligi tabiiy ravishda PDE yechimlarining silliq, global tuzilishini qamrab oladi. Bu, shuningdek, opsion to'lovlari uchun tizimli * kamchilikka * ega, biz unga qaytamiz - qisqartirilgan Furye asosi va ish tashlashdagi burilish tabiiy ittifoqchilar emas.

FNO arxitekturasi batafsil

Li va boshqalar tomonidan taqdim etilgan Furye neyron operatori. ICLR 2021 da oddiy, ammo kuchli kuzatuvga asoslanadi: ko‘plab PDElarning Green funktsiyasi (ajralmas yadro) Furye fazosida ixcham vakillikka ega. Yadroni jismoniy makonda o'rganish o'rniga - bu talab qiladi $O(n^2)$ uchun parametrlar $n$ grid nuqtalari - FNO uni chastota fazosida faqat eng pasti bilan o'rganadi $k_{\max}$ rejimlar, murakkablikni kamaytiradi $O(n \log n)$ FFT orqali.

Iterativ arxitektura

FNO quyidagilardan iborat:

1. Ko'taruvchi qatlam $P$: kirishni kanalning asl o'lchamidan yuqori o'lchamli yashirin ko'rinishga proyeksiyalovchi nuqtali chiziqli xarita: $v_0(x) = P(a(x))$.

2. Furier qatlamlari (takrorlangan $L$ marta): Har bir qatlam amal qiladi:

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

qayerda $W_l$ mahalliy chiziqli konvertatsiyadir (nuqtaga $1 \times 1$ konvolyutsiya) va $\mathcal{K}_l$ FFT orqali amalga oshirilgan global integral operator:

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

Bu yerga $\mathcal{F}$ FFTni bildiradi, $R_l$ eng past darajaga qo'llaniladigan o'rganiladigan murakkab qiymatli og'irlik tensoridir $k_{\max}$ Furye rejimlari va $\sigma$ nuqtali chiziqli bo'lmagan faollashtirish (odatda GELU).

3. Proyeksiya qatlami $Q$: Yashirin tasvirni chiqish o'lchamiga qaytaradi: $u(x) = Q(v_L(x))$.

Nima uchun Furye fazosi?

Spektral konvolyutsiya $R_l \cdot \mathcal{F}(v_l)$ chastota sohasidagi ko'paytma bo'lib, u jismoniy fazodagi global konvolyutsiyaga teng, ammo hisoblangan $O(n \log n)$ o'rniga $O(n^2)$. Bu shunchaki samaradorlik hiylasi emas. PDE yechimlari odatda silliq va past chastotali komponentlar ustunlik qiladi. ga qisqartirish orqali $k_{\max}$ rejimlarda, FNO o'rganish mumkin bo'lgan past chastotali filtr vazifasini bajaradi, bu tabiiy ravishda eritmani tartibga soladi va yuqori chastotali artefaktlardan qochadi.

Eng muhimi, FNO diskretizatsiya-invariant deb da'vo qilinadi: bir marta o'lchamdagi panjara ustida o'qitilgan $n$, har qanday rezolyutsiyada baholanishi mumkin $m \neq n$ oddiygina FFT o'lchamini va nol to'ldirishni sozlash yoki spektr og'irliklarini qisqartirish orqali. Ushbu nol zarbali o'ta aniqlik xususiyati neyron PDE hal qiluvchilar orasida noyobdir - va bu maqoladagi birinchi da'vo iqtibos emas, balki o'lchovga loyiqdir. Quyidagi o'lchov kun tartibiga qarang.

Biz operatorni o'rganayotgan PDE

Black-Scholes PDE — olingan, atama boʻyicha ajratilgan va The Black-Scholes Formula da yopiq shakldagi chaqiruv/qoʻyish yechimi bilan berilgan — operatorning maqsadi:

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

Keyingi hamma narsa unga ma'lum javobga ega qora quti sifatida qaraydi. Bu ma'lum javob aynan nima uchun bu to'g'ri test ishi: chekli farqli chiqish bo'yicha o'qitilgan operatorga qarshi ball olish mumkin. norm.cdf adabiyotda deyarli hech qanday FNO benchmark qila olmaydigan aniq narxlar.

FNO formulasi

Muammoni operator o'rganish sifatida qayta ko'rib chiqamiz. Belgilang:

• Kirish funksiyasi $a(S, t)$: PDE parametrlarini kodlaydi. Bu o'zgaruvchanlik yuzasini o'z ichiga olishi mumkin $\sigma(S, t)$, to'lov funksiyasi va xavf-xatarsiz stavka kabi kanallar ustida stacked $(S, t)$ panjara.
• Chiqish funksiyasi $u(S, t) = V(S, t)$: optsion narxi yuzasi.

FNO o'rganadi $\mathcal{G}_\theta: a \mapsto u$ ma'lumotlar to'plamidan $(a^{(i)}, u^{(i)})$ an'anaviy hal qiluvchi tomonidan yaratilgan juftliklar. Treningdan so'ng, har qanday yangi parametr konfiguratsiyasi uchun xulosa bitta oldinga o'tishdir.

Trening ma'lumotlarini yaratish

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

Trening uchun biz minglab parametr konfiguratsiyasini tanlaymiz - har xil $\sigma \in [0.05, 0.80]$, $r \in [0.01, 0.10]$, $K \in [50, 150]$, $T \in [0.1, 2.0]$ - va har birini chekli farq usuli bilan hal qiling. Kirish-chiqish juftliklarining natijaviy ma'lumotlar to'plami FNO nimani o'rganadi.

Kengaytirish: Heston stokastik o'zgaruvchanlik modeli

Doimiy o'zgaruvchanlik ma'lum noto'g'ri taxmindir va nima uchun u muvaffaqiyatsizlikka uchradi - tabassum, semiz dumlar - [Black-Skoulz formulasi] (/uz/blog/post/black-scholes-options-pricing) ning "Qattiq haqiqat" bo'limining mavzusi. Heston uni dispersiyani ikkinchi holat o'zgaruvchisiga aylantirish orqali tuzatadi:

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

bilan $\text{Corr}(dW_1, dW_2) = \rho$. Opsion narxi uchun mos keladigan PDE $V(S, v, t)$ kosmosda ikki o'lchovli:

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

Bu erda operatorni o'rganish o'z foydasiga erishadi va argument empirik emas, balki tizimli. a bo'yicha chekli farqli sxemalar $(S, v, t)$ kabi panjara shkalasi $O(N_S \times N_v \times N_t)$, oʻzaro hosila atamasi $\partial^2 V / \partial S \partial v$ diskretlashtirishni va har bir yangi parametr to'plamini murakkablashtiradi $(\kappa, \theta, \xi, \rho, r)$ to'liq to'lovni yana to'laydi. Operator uni mashg'ulot vaqtida bir marta to'laydi. Heston PDE ning 2D fazoviy strukturasi, shuningdek, Furye qatlamlarida to'g'ridan-to'g'ri 2D FFTga mos keladi, shuning uchun quyida keltirilgan arxitektura qayta loyihalash o'rniga o'lchov o'zgarishi bilan umumlashtiriladi.

Variant narxlari uchun FNO: PyTorchni amalga oshirish

Quyida Black-Scholes operatorini o'rganish uchun to'liq, mustaqil FNO ilovasi keltirilgan. Arxitektura Li va boshqalarga ergashadi. (2021) moliyaviy sharoit uchun moslashuvlar bilan.

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)

O'quv tsikli

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

Xulosa: real vaqtda narxlash

@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 va PINNlar: Amaliy taqqoslash

Fizikadan ma'lumotga ega neyron tarmoqlari va Furye neyron operatorlari neyron tarmoqlari bilan PDElarni hal qilish uchun tubdan farqli falsafalarni ifodalaydi. Ularning kelishuvlarini tushunish operatorni o'rganish haqida umuman g'amxo'rlik qilishning amaliy sababidir.

PINNlar: Har bir misol uchun optimallashtirish

PINNlar PDE qoldiqlarini to'g'ridan-to'g'ri yo'qotishga qo'yadi - Navier-Stokes muammosi mexanizmni, avtomatik farqni qamrab oladi. physics_loss amalga oshirish va DeepMind yakkalik-qidiruv natijasi. Bu erda muhim bo'lgan yagona xususiyat strukturaviy xususiyatdir: har bir parametr to'plami uchun PINN o'qitiladi. O'zgartirish $\sigma$, $r$, $K$ yoki $T$ va siz yana noldan optimallashtirasiz.

Kuchli tomonlar: Belgilangan maʼlumotlar talab qilinmaydi. PDE tuzilishini to'g'ridan-to'g'ri amalga oshiradi. Siz yozishingiz mumkin bo'lgan har qanday PDE uchun ishlaydi.

Kamsiz tomonlar: Har bir yangi parametrlar to'plami uchun qayta o'qitish kerak $(\sigma, r, K, T)$. Ta'lim ko'pincha optimallashtirish patologiyalariga olib keladigan bir nechta yo'qotish shartlarini (PDE qoldig'i, chegara shartlari, dastlabki shartlar) muvozanatlashni o'z ichiga oladi. Konvergentsiya sekin bo'lishi mumkin - odatda har bir muammo misolida 10 000–100 000 gradient qadam. Yo'qotilgan landshaft juda konveks bo'lmagan ko'p masshtabli va xaotik tizimlarda muvaffaqiyatsizlikka uchraydi.

FNO: Amortizatsiyalangan operatorni o'rganish

FNO ma'lumotlardan yechim operatorini o'rganadi. Bu klassik hal qiluvchi tomonidan yaratilgan o'quv ma'lumotlar to'plamini talab qiladi, lekin o'qitilgandan so'ng, u butun parametr maydoni bo'ylab umumlashtiriladi.

Kuchli tomonlar: chop etilgan mezonlarda millisekunddan kichik xulosa. Qayta tayyorlanmasdan ko'rinmaydigan parametrlarga umumlashtiradi. Rezolyutsiya-invariant - past aniqlikda mashq qiling, yuqori aniqlikda baholang. Tabiiyki, spektral moyillik orqali silliq PDE yechimlarini boshqaradi.

Kamsiz tomonlar: Klassik hal qiluvchidan (haqiqiy yangi PDElar uchun tovuq-tuxum muammosi) o'quv ma'lumotlarini talab qiladi. Taxminan xato chegaralangan, lekin nolga teng emas. PDE-cheklangan yondashuvlarga qaraganda kamroq izohlanadi. Va silliq echimlarga yordam beradigan spektral moyillik - bu to'lov burilishdagi javobgarlik.

Boshdan-boshga solishtirish

Quyidagi jadval adabiyotda keltirilgan, bu yerda o‘lchanmaydi — aniqlik va tezlik satrlari Li va boshqalardan olingan. (2021) va bizning uskunamizdagi optsion narxlaridan emas, balki suyuqlik mezonlari bo'yicha keyingi ish. Strukturaviy qatorlarni (kerakli ma'lumotlar, umumlashtirish, ruxsat o'zgarmasligi) ishonchli qatorlarni o'qing.

Gibrid: Fizikadan Axborotlangan Neyron Operatorlar (PINO)

PINO (Li va boshq., 2024) ikkala yondashuvni birlashtiradi. U FNO arxitekturasidan foydalanadi, lekin PDE qoldiq atamasi bilan ma'lumotlar yo'qotilishini oshiradi:

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

Parchalanish foydali qismdir. $\mathcal{L}_{\text{data}}$ operatorni qayerda bo'lishidan qat'i nazar, hal qiluvchi chiqishiga bog'laydi; $\lambda \mathcal{L}_{\text{PDE}}$ uni siz tanlamagan hamma joyda cheklaydi, jumladan siz hech qachon namuna olmagan parametrlar maydoni hududlari. Opsion bahosi uchun bu ikkinchi muddat moliyaga xos sababga ko‘ra jozibador: PDE qoldig‘i qattiq cheklovdir, siz xulosa chiqarish vaqtida o‘z-o‘zini tekshirish sifatida ham baholashingiz mumkin, bu quyidagi qoldiq monitoringining asosi hisoblanadi.

Ishlab chiqarishni joylashtirish uchun amaliy mulohazalar

Buning umumiy yarmi - kechikish byudjetlari, ma'lumotlar quvurini qurish, drift uchun monitoring, davriy qayta o'qitish - [DeepLOB: Limit buyurtma kitoblari bo'yicha chuqur o'rganish] (/uz/blog/post/deeplob-deep-learning-order-book) ishlab chiqarish bo'limida savdo tizimidagi neyron model uchun allaqachon qoplangan. Quyida faqat operatorga xos bo'lgan narsa aytiladi.

Ma'lumot uzatish liniyasi: Parametrlar maydonidan namuna olish

O'quv ma'lumotlarini yaratish asosiy to'siq bo'lib, bozor ma'lumotlari modelidan farqli o'laroq, siz o'zingizning taqsimotingizni tanlaysiz - bu siz uni yo'qotishda ko'rinmaydigan tarzda noto'g'ri olishingiz mumkin degan ma'noni anglatadi. 4 ta parametrga ega Black-Scholes operatori uchun 5000–10000 namunalar yetarli. 5 parametr va 2D fazoviy domenga ega Heston uchun 20 000–50 000 namunalar odatiy hisoblanadi. Moslashuvchan namuna olishdan foydalaning: yechim tez oʻzgarib turadigan parametr hududlarida namunalarni kontsentrlang - pulga yaqin, muddatlari qisqa, yuqori oʻzgaruvchanlik, chunki qutining bir xil namunasi oʻz byudjetining katta qismini chuqur ITM va chuqur OTM hududlariga sarflaydi, bunda operator deyarli chiziqli boʻladi va juda kam misollardan yaxshi oʻrganadi.

Arxitekturani sozlash

• Rejimlar ($k_{\max}$): bilan boshlang $N/4$ qayerda $N$ fazoviy panjara o'lchamidir. uchun $N=256$, 32–64 rejimlardan foydalaning. Juda kam rejimlar zarba chegaralari yaqinida tafsilotlarni yo'qotadi; shovqinga juda mos keladi.
• Qatlamlar: 4 ta Furye qatlami standart hisoblanadi. Chuqurroq tarmoqlar (6–8) Heston kabi 2D muammolarni hal qilishga yordam beradi, lekin xotirani oshiradi.
• Yashirin kanallar: 1D Black-Scholes uchun 64, 2D Heston uchun 128. Muammoning murakkabligi bilan masshtab.

Aniqlik: fp32 savoli

SpectralConv1d ajratadi torch.cfloat — bitta aniqlikdagi kompleks — va har bir FFT aylana safari shu aniqlikda ishlaydi. Bu blog The GPU Precision Trap da fp32 moliyaviy quvur liniyasining ovozsiz chiqindini qaytarishini allaqachon kuzatgan, bunda matematik jihatdan to‘g‘ri prefiks yig‘indisi formulasi fp32 magnitudada halokatli tarzda yo‘qolgan. Bu erda o'xshash savol to'g'ridan-to'g'ri: at $S \approx 100$ tsentga ko'rsatilgan narxlar bilan fp32 spektrli aylanma sayohatni ushlab turadi $10^{-2}$ mutlaq yoki FFTning oraliq kattalikdagi o'sishi oxirgi muhim raqamlarni yeyadimi?

Xatolarni boshqarish

Ishlab chiqarish opsiyasi narxini aniqlash uchun siz himoya qilishingiz mumkin bo'lgan xato chegaralari kerak.

1. Kalibrlangan noaniqlik: ansamblning standart og‘ishi qamrov kafolati emas* va bu blogda buni to‘g‘ri bajarish uchun mexanizm mavjud — o‘zgarmas holat uchun ACI/DtACI bilan, Xavfni anglash uchun mos bashorat” bo‘limida ushlab turilgan parametrlar tarmog‘i bo‘yicha muvofiqlikni ajrating. Hajmi. FNO ni bo'lingan holda o'rash $(\sigma, r, K, T)$ grid narx bo'yicha taqsimlanmagan intervallarni beradi.
2. Qoldiq monitoringi: FNO prognozining PDE qoldig'ini post-hoc tekshiruvi sifatida hisoblang. Agar $\|\text{residual}\| > \epsilon$, klassik hal qiluvchiga qayting. Bu xulosa chiqarish uchun bepul - qoldiq sizda mavjud bo'lgan massivdagi chekli farqli trafaretdir.
3. Faol o‘rganish: Yuqori noaniqlikdagi ma’lumotlarni klassik hal qiluvchiga yo‘naltiring, natijalarni o‘quv majmuasiga qo‘shing va vaqti-vaqti bilan qayta o‘qing. (1) dan konformal interval kengligi tabiiy marshrutlash signalidir.

O'lchovlar bo'yicha kun tartibi

Bu yuqoridagi arxitekturani qo'llashga arziydimi yoki yo'qligini hal qiladigan qism va ularning hech biri hali bajarilmagan. U ko'milgandan ko'ra bu erda sanab o'tilgan, chunki muqobil - sarlavhani tezlashtirish - bu blogdan qochish uchun mavjud bo'lgan ro'yxatga olish.

1. Tezlashtirish raqam emas, egri chiziqdir. When the GPU Pays Off quyidagi shaklni belgilaydi: $S(B) = aB/(O + bB)$, yuqoridan ko'tarilgan-hukmron da $B=1$ hisoblash bilan bog'langan platoga va u 27x algoritmga 6,2x apparatga parchalanadigan 167x sarlavhani ko'rsatadi. FNO o'lchovi ushbu shablonga muvofiq bo'lishi kerak: devor soati oldinga o'tish $B \in \{1, 8, 64, 512\}$ va butun egri chiziqni xabar qiling. Muhim jihatdan, asosiy chiziq * vektorlashtirilgan, ko'p yadroli * chekli farqlarni echuvchi bo'lishi kerak - black_scholes_fd yuqorida talqin qilingan qoʻshaloq sikl boʻlib, maqola nomlari koʻrsatilgan aniq “eng yomon protsessorni qoʻllash” asosi va paketli GPU operatorini unga nisbatan solishtirish hech narsani anglatmaydigan raqam hosil qiladi.

2. Yopiq shaklga nisbatan aniqlik. Bu Blek-Skoulz tajribasini deyarli bepul qiladi va suyuqlik dinamikasi mezonlari buni umuman qila olmaydi: FD tomonidan yaratilgan ma'lumotlar bo'yicha mashq qiling, so'ngra aniq bo'yicha ball oling. norm.cdf bo'ylab narxlar $(\sigma, r, K, T)$ quti. Qarindoshingizga xabar bering $L^2$, va xatolik haqida xabar bering tarqatish - ayniqsa, ish tashlash yaqinida va muddati tugashiga yaqin, bu erda yechim eng kam silliq bo'ladi va kesilgan spektral asos eng ko'p kurashadi.

3. Arbitraj buzilishi. O'rganilgan operator narx yuzasi qondirishi kerak bo'lgan shakl cheklovlarini hurmat qilish uchun tarkibiy asosga ega emas: monotonlik $K$, ichida qavariqlik $K$, va $V \geq \max(S-K, 0)$. Parametrlar oynasi bo'ylab buzilish darajasini o'lchash ushbu maqolaning ochiq savoliga aylanadi - o'rganilgan operatorda arbitraj shartlariga kafolat bera olamizmi? - qo'l silkitishdan raqamga.

4. Diskretizatsiya o'zgarmasligi, tasdiqlangandan ko'ra sinovdan o'tgan. Poezd $N_S = 128$, da baholang $N_S = 512$, xato haqida xabar bering. Kutilayotgan nosozlik rejimi nomi va aniq: Gibbs jiringladi $\max(S-K, 0)$. Kesilgan Furye asosi uzluksiz birinchi hosilaga ega funktsiyani rekonstruksiya qilish uchun uning atrofida tebranadi va nolga teng o'ta o'lchamli rezolyutsiya mashg'ulot o'tkazuvchanligi hech qachon ko'rmagan rejimlarni ochish orqali buni yaxshiroq emas, balki yomonlashtirishi mumkin. Agar ish tashlash yaqinida o'ta piksellar sonini pasaytirsa, bu salbiy natija marketing da'vosidan ko'ra qimmatroq bo'ladi - FNO adabiyotida hech kim to'lov burilishlari bilan narxlash variantlarini taklif qilmaydi.

Agar 1–4 ta tajribalarni bajarib boʻlmasa, ushbu maqola yuborilmasligi kerak. Ularsiz qolgan narsa boshqa birovning ICLR qog'ozining yaxshi yozilgan ekspozitsiyasidir.

Vanilla opsiyalaridan tashqari

Yuqoridagi kun tartibi o'lchov bilan aloqada bo'lsa, FNO ramkasi tabiiy ravishda yanada murakkab asboblarga tarqaladi:

• Amerika variantlari: Qo'shimcha chiqish kanali sifatida erta mashq chegarasini qo'shing. FNO bir vaqtning o'zida narx sirtini ham, optimal mashqlar chegarasini ham o'rganadi.
• To‘siq imkoniyatlari: To‘siq darajalarini kirish kanallari sifatida kodlash. E'tibor bering, to'siq ikkinchi uzilishdir va o'lchov kun tartibidagi Gibbs tashvishi kamroq emas, balki ko'proq kuch bilan qo'llaniladi.
• Ko‘p obyektli savat: 2–3 ta asosiy savatdagi variantlar uchun 2D yoki 3D FNO dan foydalaning. O'lchovlilikning la'nati gridga asoslangan hal qiluvchilarga qaraganda kamroq kuchli, chunki FNO ma'lum miqdordagi rejimlarda ishlaydi.
• Mahalliy o'zgaruvchanlik: To'liq Dupire mahalliy o'zgaruvchanlik yuzasini kiriting $\sigma_{\text{loc}}(S,t)$ fazoviy funktsiya sifatida. Bu operatorni o'rganish uchun eng tabiiy foydalanish holatidir - kiritish * skaler parametr emas, balki funksiyadir.

Xulosa

Furye Neyron Operatorining hissasi hisoblashdan oldin kontseptualdir: bir vaqtning o'zida bitta PDE ni hal qilish o'rniga, siz yechim operatorining o'zini parametrlashtirasiz va Furye fazosida buni amalga oshirish arxitekturani beradi $O(n \log n)$, uzluksiz operatorlarda universal va qurilishi bo'yicha o'lchamlari moslashuvchan. Bu Li va boshqalardan kelib chiqadi. (2021) va yuqoridagi koddan, qaysi ishlaydi.

Unga amal qilmaydigan narsa tezlikni oshirish raqamidir. Adabiyotning 100x–1000x ko'rsatkichlari suyuqlik mezonlari bo'yicha o'lchanadi, ularning sifati kamdan-kam qayd etiladi va bu turkumda bunday sarlavhaning qanchalik ko'p qismi odatda apparat emas, balki algoritm ekanligini ko'rsatadigan butun maqolani o'tkazdi. Operatorni narxlash mexanizmiga qo'yishni oqlaydigan da'volar - tsent-darajali fp32 aniqligi, cheklangan arbitraj buzilishi darajasi, to'lov burilishidan omon qoladigan o'ta rezolyutsiya va vakolatli protsessor hal qiluvchiga nisbatan tezlikni oshirish egri chizig'i - barchasini o'lchash mumkin, hammasi Blek-Scholesda arzon, chunki bu erda hammasi yopiq va hali ham mavjud emas.

Bu loyihaning holati shunday: mexanizm haqiqiy, va'da ishonchli va dalillar kutilmoqda.

Ma'lumotnomalar va qo'shimcha o'qish:

• Li, Z., Kovachki, N., Azizzadenesheli, K. va boshqalar. "Parametrik qisman differentsial tenglamalar uchun Furye neyron operatori". ICLR 2021. arXiv:2010.08895
• Lu, L., Jin, P., Pang, G., Chjan, Z. va Karniadakis, G.E. "DeepONet orqali chiziqli bo'lmagan operatorlarni o'rganish." Nature Machine Intelligence, 2021. doi: 10.1038/s42256-021-00302-5
• Li, Z. va boshqalar. "Qisman differentsial tenglamalarni o'rganish uchun fizika-ma'lumotli neyron operatori". ACM/IMS Data Science jurnali, 2024. OpenReview
• neuraloperator PyTorch kutubxonasi: github.com/neuraloperator/neuraloperator
• Salvador, M. va boshqalar. "Opsion narxlari uchun Blek-Skoulz tenglamasini neyron tarmog'ini o'rganish." arXiv:2405.05780
• Bai, Y. va boshqalar. "AI Black-Scholes: Moliyadan ma'lumotga ega neyron tarmoq." arXiv:2412.12213