पीडीई-आधारित वित्तीय मॉडलिंग के लिए फूरियर न्यूरल ऑपरेटर

इस ब्लॉग पर अब तक प्रत्येक तंत्रिका नेटवर्क ने एक फ़ंक्शन का अनुमान लगाया है: सुविधाएँ अंदर, संख्या बाहर। फूरियर न्यूरल ऑपरेटर एक ऑपरेटर का अनुमान लगाता है - अनंत-आयामी फ़ंक्शन स्थानों के बीच एक मानचित्र, जहां इनपुट एक संपूर्ण अस्थिरता सतह है और आउटपुट एक संपूर्ण मूल्य सतह है। यह एक अलग वस्तु है, इसे अलग मशीनरी की आवश्यकता है, और मशीनरी इस आलेख का बिंदु है: सबसे कम फूरियर मोड पर लागू एक सीखने योग्य जटिल-मूल्यवान कर्नेल, एफएफटी राउंड-ट्रिप के माध्यम से मूल्यांकन किया गया $O(n \log n)$ .

विकल्प मूल्य निर्धारण वह जगह है जहां यह वित्त में आता है। ब्लैक-स्कोल्स, हेस्टन, स्थानीय अस्थिरता - सभी पीडीई, सभी को आज एक समय में निर्धारित एक पैरामीटर से हल किया गया। एक ऑपरेटर एक ही बार में पूरे पैरामीटर परिवार को सीखता है, और परिणामी फॉरवर्ड पास टाइम-मार्चिंग लूप के बजाय एकल बैच वाला जीपीयू कर्नेल होता है।

यही वादा है. इस लेख का ईमानदार संस्करण यांत्रिकी को अलग करता है, जो नीचे दिए गए कोड से ठोस और प्रतिलिपि प्रस्तुत करने योग्य है, प्रदर्शन के दावों से, जो एफएनओ साहित्य में आधारभूत आधार के विरुद्ध रिपोर्ट किए गए हैं, इस श्रृंखला में कोई भी बिना जांचे स्वीकार नहीं करेगा। यांत्रिकी पहले आते हैं; माप एजेंडा अंत में आता है, जिसे अनरन के रूप में चिह्नित किया जाता है।

फंक्शन एप्रोक्सिमेशन से लेकर ऑपरेटर लर्निंग तक

शास्त्रीय तंत्रिका नेटवर्क अनुमानित कार्य: एक इनपुट दिया गया $x \in \mathbb{R}^n$ , वे एक आउटपुट उत्पन्न करते हैं $y \in \mathbb{R}^m$ . यह शक्तिशाली है, लेकिन मूल रूप से सीमित है जब रुचि की वस्तुएं स्वयं कार्य होती हैं। वित्तीय पीडीई समाधान में, इनपुट एक एकल संख्या नहीं है - यह प्रारंभिक/सीमा स्थितियों, एक अस्थिरता सतह, या एक शब्द संरचना का वर्णन करने वाला एक फ़ंक्शन है। आउटपुट एक अन्य कार्य है: कीमत सतह पर $(S, t)$ अंतरिक्ष।

ऑपरेटर लर्निंग समस्या को अनंत-आयामी स्थानों तक ले जाता है। सीखने के बजाय $f: \mathbb{R}^n \to \mathbb{R}^m$ , हम एक ऑपरेटर सीखते हैं:

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

कहाँ $\mathcal{A}$ और $\mathcal{U}$ कार्यों के बनच स्थान हैं। विकल्प मूल्य निर्धारण के लिए, $\mathcal{A}$ अस्थिरता सतहों का स्थान हो सकता है $\sigma(S,t)$ और $\mathcal{U}$ संगत मूल्य सतहों का स्थान $V(S,t)$ .

ऑपरेटर सीखने के परिदृश्य पर दो आर्किटेक्चर हावी हैं:

डीपोनेट (लू एट अल., 2021): इनपुट फ़ंक्शन को एनकोड करने के लिए एक शाखा नेटवर्क और क्वेरी स्थान को एनकोड करने के लिए एक ट्रंक नेटवर्क का उपयोग करता है। आउटपुट उनका आंतरिक उत्पाद है। चेन और चेन (1995) द्वारा ऑपरेटरों के लिए सार्वभौमिक सन्निकटन प्रमेय पर आधारित।
फूरियर न्यूरल ऑपरेटर (ली एट अल., 2021): कुशल वैश्विक कनवल्शन के लिए एफएफटी का उपयोग करते हुए, फूरियर स्पेस में इंटीग्रल कर्नेल को पैरामीटराइज़ करता है। निर्माण द्वारा संकल्प-अपरिवर्तनीय।

दोनों निरंतर ऑपरेटरों के लिए सार्वभौमिक सन्निकटन हैं, लेकिन एफएनओ के पास पीडीई समस्याओं के लिए एक संरचनात्मक लाभ है: इसका वर्णक्रमीय पूर्वाग्रह स्वाभाविक रूप से पीडीई समाधानों की चिकनी, वैश्विक संरचना को पकड़ लेता है। इसमें विशेष रूप से विकल्प भुगतान के लिए एक संरचनात्मक नुकसान भी है, जिस पर हम वापस आएंगे - एक छोटा फूरियर आधार और हड़ताल पर एक किंक प्राकृतिक सहयोगी नहीं हैं।

एफएनओ आर्किटेक्चर विस्तार से

फूरियर न्यूरल ऑपरेटर, ली एट अल द्वारा प्रस्तुत किया गया। आईसीएलआर 2021 में, एक सरल लेकिन शक्तिशाली अवलोकन पर आधारित है: कई पीडीई के ग्रीन फ़ंक्शन (इंटीग्रल कर्नेल) का फूरियर स्पेस में एक कॉम्पैक्ट प्रतिनिधित्व है। भौतिक स्थान में एक कर्नेल सीखने के बजाय - जिसकी आवश्यकता है $O(n^2)$ के लिए पैरामीटर $n$ ग्रिड बिंदु - एफएनओ इसे केवल सबसे कम के साथ आवृत्ति स्थान में सीखता है $k_{\max}$ मोड, जटिलता को कम करना $O(n \log n)$ एफएफटी के माध्यम से.

पुनरावृत्तीय वास्तुकला

एक एफएनओ में शामिल हैं:

उठाने वाली परत $P$ : एक बिंदुवार रैखिक मानचित्र जो इनपुट को उसके मूल चैनल आयाम से उच्च-आयामी अव्यक्त प्रतिनिधित्व में प्रोजेक्ट करता है: $v_0(x) = P(a(x))$ .
फूरियर परतें (दोहराया गया $L$ समय): प्रत्येक परत लागू होती है:

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

कहाँ $W_l$ एक स्थानीय रैखिक परिवर्तन (बिंदुवार) है $1 \times 1$ कनवल्शन) और $\mathcal{K}_l$ एफएफटी के माध्यम से कार्यान्वित एक वैश्विक अभिन्न ऑपरेटर है:

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

यहाँ $\mathcal{F}$ एफएफटी को दर्शाता है, $R_l$ एक सीखने योग्य जटिल-मूल्यवान भार टेंसर है जिसे निम्नतम पर लागू किया जाता है $k_{\max}$ फूरियर मोड, और $\sigma$ एक बिंदुवार अरेखीय सक्रियण (आमतौर पर GELU) है।

प्रक्षेपण परत $Q$ : अव्यक्त प्रतिनिधित्व को आउटपुट आयाम पर वापस मैप करता है: $u(x) = Q(v_L(x))$ .

फूरियर स्पेस क्यों?

वर्णक्रमीय कनवल्शन $R_l \cdot \mathcal{F}(v_l)$ आवृत्ति डोमेन में एक गुणन है, जो भौतिक स्थान में वैश्विक कनवल्शन के बराबर है - लेकिन इसकी गणना की जाती है $O(n \log n)$ के बजाय $O(n^2)$ . यह सिर्फ एक दक्षता युक्ति नहीं है. पीडीई समाधान आम तौर पर सुचारू होते हैं और कम आवृत्ति वाले घटकों का प्रभुत्व होता है। को छोटा करके $k_{\max}$ मोड में, एफएनओ एक सीखने योग्य कम-पास फिल्टर के रूप में कार्य करता है जो स्वाभाविक रूप से समाधान को नियमित करता है और उच्च-आवृत्ति कलाकृतियों से बचाता है।

महत्वपूर्ण रूप से, एफएनओ को विवेकाधीन-अपरिवर्तनीय होने का दावा किया जाता है: एक बार आकार के ग्रिड पर प्रशिक्षित किया जाता है $n$ , इसका मूल्यांकन किसी भी संकल्प पर किया जा सकता है $m \neq n$ बस एफएफटी आकार को समायोजित करके और शून्य-पैडिंग या वर्णक्रमीय भार को छोटा करके। यह शून्य-शॉट सुपर-रिज़ॉल्यूशन संपत्ति तंत्रिका पीडीई सॉल्वरों के बीच अद्वितीय है - और यह इस आलेख में पहला दावा है जो उद्धरण के बजाय माप के योग्य है। नीचे माप एजेंडा देखें।

जिस पीडीई के लिए हम ऑपरेटर सीख रहे हैं

ब्लैक-स्कोल्स पीडीई - व्युत्पन्न, शब्द दर शब्द विच्छेदित, और [द ब्लैक-स्कोल्स फॉर्मूला] (/hi/blog/post/black-scholes-options-pricing) में इसके बंद-फॉर्म कॉल/पुट समाधान के साथ दिया गया है - ऑपरेटर लक्ष्य है:

$\frac{\partial V}{\partial t} + \frac{1}{2}\sigma^2 S^2 \frac{\partial^2 V}{\partial S^2} + rS\frac{\partial V}{\partial S} - rV = 0$

इसके बाद जो कुछ भी आता है वह इसे एक ज्ञात उत्तर के साथ एक ब्लैक बॉक्स के रूप में मानता है। यह ज्ञात उत्तर बिल्कुल यही है कि यह सही परीक्षण मामला क्यों है: परिमित-अंतर आउटपुट पर प्रशिक्षित ऑपरेटर को इसके विरुद्ध स्कोर किया जा सकता है norm.cdf सटीक कीमतें, जो साहित्य में लगभग कोई भी एफएनओ बेंचमार्क नहीं कर सकता है।

एफएनओ फॉर्मूलेशन

हम समस्या को ऑपरेटर लर्निंग के रूप में पुनः प्रस्तुत करते हैं। परिभाषित करें:

इनपुट फ़ंक्शन $a(S, t)$ : PDE मापदंडों को एन्कोड करता है। इसमें अस्थिरता सतह शामिल हो सकती है $\sigma(S, t)$ , भुगतान फ़ंक्शन, और चैनलों पर जोखिम-मुक्त दर $(S, t)$ ग्रिड।
आउटपुट फ़ंक्शन $u(S, t) = V(S, t)$ : विकल्प मूल्य सतह।

एफएनओ सीखता है $\mathcal{G}_\theta: a \mapsto u$ के डेटासेट से $(a^{(i)}, u^{(i)})$ पारंपरिक सॉल्वर द्वारा उत्पन्न जोड़े। प्रशिक्षण के बाद, किसी भी नए पैरामीटर कॉन्फ़िगरेशन का अनुमान एक एकल फॉरवर्ड पास है।

प्रशिक्षण डेटा सृजन

import numpy as np
from scipy.stats import norm

def black_scholes_fd(sigma, r, K, T, S_max=300, N_S=256, N_t=256):
    """Solve Black-Scholes PDE via explicit finite differences.

    NOTE: this is an interpreted double loop — the *worst* CPU baseline,
    exactly the kind called out in /en/blog/post/when-gpu-pays-off-sweep-roofline.
    It is fine for generating training data offline. It is NOT the baseline
    any speedup claim should be measured against; vectorize the inner loop
    over i (or use scipy sparse + implicit stepping) before timing anything.
    """
    dS = S_max / N_S
    dt = T / N_t
    S = np.linspace(0, S_max, N_S + 1)

    # Terminal condition: European call payoff
    V = np.maximum(S - K, 0).astype(np.float64)

    # Backward time-stepping
    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]
            )
        # Boundary conditions
        V_new[0] = 0
        V_new[N_S] = S_max - K * np.exp(-r * (T - (j+1)*dt))
        V = V_new

    return S, V

प्रशिक्षण के लिए, हम हजारों पैरामीटर कॉन्फ़िगरेशन का नमूना लेते हैं - अलग-अलग $\sigma \in [0.05, 0.80]$ , $r \in [0.01, 0.10]$ , $K \in [50, 150]$ , $T \in [0.1, 2.0]$ - और प्रत्येक को परिमित-अंतर विधि से हल करें। इनपुट-आउटपुट जोड़े के परिणामी डेटासेट से एफएनओ सीखता है।

स्केलिंग अप: हेस्टन स्टोकेस्टिक अस्थिरता मॉडल

निरंतर अस्थिरता एक ज्ञात-झूठी धारणा है, और यह विफल क्यों होती है - मुस्कुराहट, मोटी पूंछ - [द ब्लैक-स्कोल्स फॉर्मूला] (/hi/blog/post/black-scholes-options-pricing) के "कठोर वास्तविकता" खंड का विषय है। हेस्टन विचरण को दूसरा राज्य चर बनाकर इसे ठीक करता है:

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

साथ $\text{Corr}(dW_1, dW_2) = \rho$ . विकल्प मूल्य के लिए संबंधित पीडीई $V(S, v, t)$ अंतरिक्ष में द्वि-आयामी है:

$\frac{\partial V}{\partial t} + \frac{1}{2}vS^2\frac{\partial^2 V}{\partial S^2} + \rho\xi vS\frac{\partial^2 V}{\partial S \partial v} + \frac{1}{2}\xi^2 v\frac{\partial^2 V}{\partial v^2} + rS\frac{\partial V}{\partial S} + \kappa(\theta - v)\frac{\partial V}{\partial v} - rV = 0$

यह वह जगह है जहां संचालक शिक्षण अपनी पकड़ बना लेता है, और तर्क अनुभवजन्य के बजाय संरचनात्मक है। ए पर परिमित-अंतर योजनाएं $(S, v, t)$ ग्रिड पैमाने के रूप में $O(N_S \times N_v \times N_t)$ , क्रॉस-व्युत्पन्न शब्द $\partial^2 V / \partial S \partial v$ विवेकीकरण और प्रत्येक नए पैरामीटर सेट को जटिल बनाता है $(\kappa, \theta, \xi, \rho, r)$ फिर से पूरी लागत का भुगतान करता है. एक ऑपरेटर प्रशिक्षण के समय इसका भुगतान एक बार करता है। हेस्टन पीडीई की 2डी स्थानिक संरचना भी फूरियर परतों में 2डी एफएफटी पर सीधे मैप करती है, इसलिए नीचे दिया गया आर्किटेक्चर रीडिज़ाइन के बजाय आयाम परिवर्तन के साथ सामान्यीकृत होता है।

विकल्प मूल्य निर्धारण के लिए FNO: PyTorch कार्यान्वयन

ब्लैक-स्कोल्स ऑपरेटर को सीखने के लिए नीचे एक पूर्ण, स्व-निहित एफएनओ कार्यान्वयन है। वास्तुकला ली एट अल का अनुसरण करती है। (2021) वित्तीय सेटिंग के लिए अनुकूलन के साथ।

import torch
import torch.nn as nn
import torch.nn.functional as F
from torch.fft import rfft, irfft

class SpectralConv1d(nn.Module):
    """1D Fourier layer: spectral convolution via FFT."""

    def __init__(self, in_channels: int, out_channels: int, modes: int):
        super().__init__()
        self.in_channels = in_channels
        self.out_channels = out_channels
        self.modes = modes  # Number of Fourier modes to keep

        scale = 1.0 / (in_channels * out_channels)
        self.weights = nn.Parameter(
            scale * torch.randn(in_channels, out_channels, modes, dtype=torch.cfloat)
        )

    def forward(self, x: torch.Tensor) -> torch.Tensor:
        # x shape: (batch, channels, spatial)
        batch_size = x.shape[0]

        # FFT along spatial dimension
        x_ft = rfft(x, dim=-1)

        # Multiply relevant Fourier modes
        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
        )

        # Inverse FFT
        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 shape: (batch, spatial, in_channels)
        x = self.lift(x)                    # -> (batch, spatial, hidden)
        x = x.permute(0, 2, 1)              # -> (batch, hidden, spatial)

        for block in self.blocks:
            x = block(x)

        x = x.permute(0, 2, 1)              # -> (batch, spatial, hidden)
        return self.proj(x)                  # -> (batch, spatial, out_channels)

प्रशिक्षण लूप

import torch.optim as optim
from torch.utils.data import DataLoader, TensorDataset

def train_fno_black_scholes():
    device = torch.device("cuda" if torch.cuda.is_available() else "cpu")

    # --- Data generation (offline, using FD solver) ---
    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)

        # Input channels: volatility, payoff, normalized grid
        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 ---
    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)

    # --- Training ---
    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)
            # Relative L2 loss — standard for operator learning
            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

# model = train_fno_black_scholes()

अनुमान: वास्तविक समय मूल्य निर्धारण

@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()

# Example: price with sigma=0.25, K=100 across all S values
# prices = price_option(model, sigma=0.25, K=100.0, S_grid=S_grid)

एफएनओ बनाम पिनन: एक व्यावहारिक तुलना

भौतिकी-सूचित तंत्रिका नेटवर्क और फूरियर न्यूरल ऑपरेटर तंत्रिका नेटवर्क के साथ पीडीई को हल करने के लिए मौलिक रूप से अलग-अलग दर्शन का प्रतिनिधित्व करते हैं। ऑपरेटर सीखने की परवाह करने का व्यावहारिक कारण उनके ट्रेड-ऑफ को समझना है।

पिनन: प्रति-घटना अनुकूलन

पिनन पीडीई अवशिष्ट को सीधे नुकसान में डालते हैं - [नेवियर-स्टोक्स समस्या] (/hi/blog/post/navier-stokes-problem) तंत्र को कवर करती है, ऑटोडिफ़ physics_loss कार्यान्वयन, और डीपमाइंड विलक्षणता-खोज परिणाम। एकमात्र संपत्ति जो यहां मायने रखती है वह संरचनात्मक है: ** एक पिनएन को प्रति पैरामीटर सेट पर प्रशिक्षित किया जाता है। ** परिवर्तन $\sigma$ , $r$ , $K$ या $T$ और आप स्क्रैच से फिर से अनुकूलन करते हैं।

ताकतें: किसी लेबल किए गए डेटा की आवश्यकता नहीं है। सीधे पीडीई संरचना को लागू करता है। किसी भी पीडीई के लिए काम करता है जिसे आप लिख सकते हैं।

कमजोरियाँ: प्रत्येक नए पैरामीटर सेट के लिए पुनः प्रशिक्षित होना चाहिए $(\sigma, r, K, T)$ . प्रशिक्षण में कई हानि शर्तों (पीडीई अवशिष्ट, सीमा स्थितियां, प्रारंभिक स्थितियां) को संतुलित करना शामिल है जो अक्सर अनुकूलन विकृति की ओर ले जाता है। अभिसरण धीमा हो सकता है - आमतौर पर प्रति समस्या उदाहरण 10,000-100,000 ग्रेडिएंट चरण। बहु-स्तरीय और अराजक प्रणालियों पर विफल हो जाता है जहां नुकसान का परिदृश्य अत्यधिक गैर-उत्तल हो जाता है।

एफएनओ: परिशोधित ऑपरेटर लर्निंग

एफएनओ डेटा से समाधान ऑपरेटर सीखता है। इसके लिए क्लासिकल सॉल्वर द्वारा उत्पन्न प्रशिक्षण डेटासेट की आवश्यकता होती है, लेकिन एक बार प्रशिक्षित होने के बाद, यह संपूर्ण पैरामीटर स्पेस में सामान्यीकृत हो जाता है।

ताकतें: प्रकाशित बेंचमार्क में उप-मिलीसेकंड अनुमान। पुन:प्रशिक्षण के बिना अनदेखे मापदंडों को सामान्यीकृत करता है। रिज़ॉल्यूशन-अपरिवर्तनीय - कम रिज़ॉल्यूशन पर प्रशिक्षण, उच्च रिज़ॉल्यूशन पर मूल्यांकन करें। वर्णक्रमीय पूर्वाग्रह के माध्यम से स्वाभाविक रूप से सुचारू पीडीई समाधानों को संभालता है।

कमजोरियां: एक क्लासिकल सॉल्वर से प्रशिक्षण डेटा की आवश्यकता होती है (वास्तव में नए पीडीई के लिए चिकन और अंडे की समस्या)। सन्निकटन त्रुटि सीमित है लेकिन शून्य नहीं है। पीडीई-विवश दृष्टिकोणों की तुलना में कम व्याख्या योग्य। और वर्णक्रमीय पूर्वाग्रह जो सुचारु समाधानों में मदद करता है, एक भुगतान किंक पर एक दायित्व है।

आमने-सामने की तुलना

नीचे दी गई तालिका साहित्य-रिपोर्ट की गई है, यहां मापी नहीं गई है - विशेष रूप से सटीकता और स्पीडअप पंक्तियां ली एट अल से आती हैं। (2021) और तरल बेंचमार्क पर अनुवर्ती कार्य, न कि हमारे हार्डवेयर पर विकल्प मूल्य निर्धारण से। संरचनात्मक पंक्तियों (आवश्यक डेटा, सामान्यीकरण, रिज़ॉल्यूशन इनवेरिएंस) को विश्वसनीय के रूप में पढ़ें।

कसौटी	पिनन	एफएनओ
प्रशिक्षण डेटा की आवश्यकता	कोई नहीं (पर्यवेक्षित नहीं)	सॉल्वर-जनित जोड़े
अनुमान लागत	प्रति उदाहरण पूर्ण पुनर्प्रशिक्षण	सिंगल फॉरवर्ड पास
सामान्यीकरण	एकल पैरामीटर सेट	संपूर्ण पैरामीटर परिवार
संकल्प अपरिवर्तनीयता	नहीं	हाँ का दावा किया गया - नीचे एजेंडा देखें
मल्टी-स्केल पीडीई	अक्सर विफल रहता है	मजबूत रिपोर्ट की गई
सटीकता (सापेक्ष) $L^2$ , साहित्य)	$10^{-3}$ को $10^{-2}$	$10^{-4}$ को $10^{-3}$

हाइब्रिड: भौतिकी-सूचित तंत्रिका संचालक (पिनो)

पिनो (ली एट अल., 2024) दोनों दृष्टिकोणों को जोड़ता है। यह एफएनओ आर्किटेक्चर का उपयोग करता है लेकिन पीडीई अवशिष्ट शब्द के साथ डेटा-संचालित हानि को बढ़ाता है:

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

अपघटन उपयोगी भाग है. $\mathcal{L}_{\text{data}}$ जहां भी आपके पास सॉल्वर आउटपुट है, वहां ऑपरेटर को एंकर करता है; $\lambda \mathcal{L}_{\text{PDE}}$ इसे हर जगह प्रतिबंधित करता है जहां आप नहीं करते हैं, जिसमें पैरामीटर स्पेस के क्षेत्र भी शामिल हैं जिनका आपने कभी नमूना नहीं लिया है। विकल्प मूल्य निर्धारण के लिए, दूसरा कार्यकाल वित्त के लिए विशिष्ट कारण से आकर्षक है: पीडीई अवशिष्ट एक कठिन बाधा है, आप अनुमान समय पर स्व-जांच के रूप में भी मूल्यांकन कर सकते हैं, जो नीचे दिए गए अवशिष्ट-निगरानी फ़ॉलबैक का आधार है।

उत्पादन परिनियोजन के लिए व्यावहारिक विचार

इसका सामान्य आधा हिस्सा - अनुमान विलंबता बजट, डेटा पाइपलाइन का निर्माण, बहाव की निगरानी, आवधिक पुनर्प्रशिक्षण - पहले से ही [डीपएलओबी: डीप लर्निंग ऑन लिमिट ऑर्डर बुक्स] (/hi/blog/post/deeplob-deep-learning-order-book) के उत्पादन अनुभाग में एक ट्रेडिंग सिस्टम में एक तंत्रिका मॉडल के लिए कवर किया गया है, और यह अपरिवर्तित लागू होता है। जो कुछ आगे आता है वह केवल वही है जो एक ऑपरेटर के लिए विशिष्ट है।

डेटा पाइपलाइन: पैरामीटर स्पेस का नमूनाकरण

प्रशिक्षण डेटा उत्पन्न करना मुख्य बाधा है, और बाजार-डेटा मॉडल के विपरीत, आप अपना स्वयं का वितरण चुनते हैं - जिसका अर्थ है कि आप इसे इस तरह से गलत कर सकते हैं जो नुकसान में अदृश्य है। 4 मापदंडों वाले ब्लैक-स्कोल्स ऑपरेटर के लिए, 5,000-10,000 नमूने पर्याप्त हैं। 5 मापदंडों और 2डी स्थानिक डोमेन वाले हेस्टन के लिए, 20,000-50,000 नमूने विशिष्ट हैं। अनुकूली नमूनाकरण का उपयोग करें: पैरामीटर क्षेत्रों में नमूनों को केंद्रित करें जहां समाधान तेजी से बदलता है - पैसे के पास, कम परिपक्वता, उच्च अस्थिरता - क्योंकि बॉक्स का समान नमूनाकरण अपने बजट का अधिकांश हिस्सा डीप-आईटीएम और डीप-ओटीएम क्षेत्रों पर खर्च करता है जहां ऑपरेटर लगभग रैखिक होता है और बहुत कम उदाहरणों से ठीक सीखता है।

आर्किटेक्चर ट्यूनिंग

मोड ( $k_{\max}$ ): के साथ शुरू $N/4$ कहाँ $N$ स्थानिक ग्रिड आकार है. के लिए $N=256$ , 32-64 मोड का उपयोग करें। बहुत कम मोड स्ट्राइक सीमाओं के पास विवरण खो देते हैं; शोर के प्रति बहुत अधिक अनुकूलता।
परतें: 4 फूरियर परतें मानक हैं। गहरे नेटवर्क (6-8) हेस्टन जैसी 2डी समस्याओं में मदद करते हैं लेकिन मेमोरी बढ़ाते हैं।
छिपे हुए चैनल: 1डी ब्लैक-स्कोल्स के लिए 64, 2डी हेस्टन के लिए 128। समस्या की जटिलता के साथ पैमाना.

परिशुद्धता: fp32 प्रश्न

SpectralConv1d आबंटित करता है torch.cfloat - एकल-परिशुद्धता कॉम्प्लेक्स - और प्रत्येक एफएफटी राउंड-ट्रिप उस परिशुद्धता पर चलती है। इस ब्लॉग ने पहले से ही एक fp32 वित्तीय पाइपलाइन को द GPU प्रिसिजन ट्रैप में मूक कचरा लौटाते हुए देखा है, जहां गणितीय रूप से सही उपसर्ग-योग फॉर्मूलेशन fp32 परिमाण में भयावह रूप से खो गया है। यहाँ समान प्रश्न प्रत्यक्ष है: पर $S \approx 100$ सेंट तक उद्धृत कीमतों के साथ, क्या एफपी32 वर्णक्रमीय राउंड-ट्रिप कायम है $10^{-2}$ निरपेक्ष, या क्या एफएफटी की मध्यवर्ती परिमाण वृद्धि अंतिम महत्वपूर्ण अंकों को खा जाती है?

त्रुटि नियंत्रण

उत्पादन विकल्प मूल्य निर्धारण के लिए, आपको त्रुटि सीमा की आवश्यकता है जिसका आप बचाव कर सकें।

कैलिब्रेटेड अनिश्चितता: एक एकीकृत मानक विचलन एक कवरेज गारंटी नहीं है, और इस ब्लॉग में इसे ठीक से करने की मशीनरी है - गैर-विनिमय योग्य मामले के लिए एसीआई/डीटीएसीआई के साथ, एक हेल्ड-आउट पैरामीटर ग्रिड पर कंफर्मल को विभाजित करें, जोखिम-जागरूक स्थिति आकार के लिए कंफर्मल भविष्यवाणी। एफएनओ को स्प्लिट कंफर्मल में लपेटना $(\sigma, r, K, T)$ ग्रिड कीमत पर वितरण-मुक्त अंतराल देता है।
अवशिष्ट निगरानी: पोस्ट-हॉक जांच के रूप में एफएनओ भविष्यवाणी के पीडीई अवशेष की गणना करें। अगर $\|\text{residual}\| > \epsilon$ , एक शास्त्रीय सॉल्वर पर वापस आएं। यह अनुमान लगाने के लिए मुफ़्त है - अवशिष्ट आपके पास पहले से मौजूद सरणी पर एक सीमित-अंतर स्टैंसिल है।
सक्रिय शिक्षण: उच्च-अनिश्चितता वाले इनपुट को क्लासिकल सॉल्वर तक रूट करें, परिणामों को प्रशिक्षण सेट में जोड़ें, और समय-समय पर पुनः प्रशिक्षित करें। (1) से अनुरूप अंतराल चौड़ाई प्राकृतिक रूटिंग सिग्नल है।

मापन एजेंडा

यह वह हिस्सा है जो यह तय करता है कि उपरोक्त आर्किटेक्चर तैनात करने लायक है या नहीं, और इसमें से कुछ भी अभी तक नहीं किया गया है। इसे दफनाने के बजाय यहां सूचीबद्ध किया गया है क्योंकि विकल्प - हेडलाइन स्पीडअप पर जोर देना - बिल्कुल वही रजिस्टर है जिससे बचने के लिए यह ब्लॉग मौजूद है।

1. स्पीडअप एक वक्र है, संख्या नहीं। जब GPU भुगतान करता है आकार स्थापित करता है: $S(B) = aB/(O + bB)$ , ओवरहेड-वर्चस्व से बढ़ रहा है $B=1$ एक कंप्यूट-बाउंड पठार के लिए, और यह एक हेडलाइन 167x को 27x एल्गोरिदम गुना हार्डवेयर के 6.2x में विघटित दिखाता है। एफएनओ माप को उस टेम्पलेट का पालन करना चाहिए: दीवार-घड़ी आगे की ओर गुजरती है $B \in \{1, 8, 64, 512\}$ और संपूर्ण वक्र की रिपोर्ट करें. गंभीर रूप से, आधार रेखा एक वेक्टरीकृत, मल्टी-कोर परिमित-अंतर सॉल्वर होनी चाहिए - black_scholes_fd ऊपर एक व्याख्या किया गया डबल लूप है, सटीक "सबसे खराब सीपीयू कार्यान्वयन" बेसलाइन जो लेख का नाम है, और इसके खिलाफ एक बैच जीपीयू ऑपरेटर की तुलना करने से एक संख्या उत्पन्न होगी जिसका कोई मतलब नहीं है।

**2. बंद फॉर्म के विरुद्ध सटीकता। ** यह वह प्रयोग है जिसे ब्लैक-स्कोल्स लगभग मुफ़्त बनाता है और द्रव-गतिकी बेंचमार्क बिल्कुल भी नहीं कर सकते: एफडी-जनरेटेड डेटा पर प्रशिक्षण, फिर सटीक के विरुद्ध स्कोर norm.cdf कीमतें भर में $(\sigma, r, K, T)$ डिब्बा। रिश्तेदार को रिपोर्ट करें $L^2$ , और त्रुटि वितरण की रिपोर्ट करें - विशेष रूप से हड़ताल के निकट और समाप्ति के निकट, जहां समाधान कम से कम सुचारू है और कटे हुए वर्णक्रमीय आधार को सबसे अधिक संघर्ष करना चाहिए।

3. कोई मध्यस्थता उल्लंघन नहीं। एक विद्वान ऑपरेटर के पास आकार की बाधाओं का सम्मान करने का कोई संरचनात्मक कारण नहीं है, कीमत की सतह को संतुष्ट करना होगा: एकरसता में $K$ , में उत्तलता $K$ , और $V \geq \max(S-K, 0)$ . पैरामीटर बॉक्स में उल्लंघन की दर को मापने से इस लेख का अपना खुला प्रश्न बदल जाता है - क्या हम सीखे हुए ऑपरेटर में कोई मध्यस्थता की स्थिति की गारंटी नहीं दे सकते? - हाथ हिलाने से एक संख्या में।

**4. विवेकाधीन अपरिवर्तनीयता, दावे के बजाय परीक्षण किया गया। ** पर प्रशिक्षण $N_S = 128$ , पर मूल्यांकन करें $N_S = 512$ , त्रुटि की रिपोर्ट करें। अपेक्षित विफलता मोड का नाम और विशिष्ट है: गिब्स रिंगिंग एट द किंक $\max(S-K, 0)$ . एक छोटा फूरियर आधार एक फ़ंक्शन को उसके चारों ओर एक असंतत प्रथम व्युत्पन्न दोलन के साथ पुनर्निर्माण करता है, और शून्य-शॉट सुपर-रिज़ॉल्यूशन उन मोड को उजागर करके इसे बेहतर के बजाय बदतर बना सकता है जो प्रशिक्षण रिज़ॉल्यूशन ने कभी नहीं देखा था। यदि स्ट्राइक के निकट सुपर-रिज़ॉल्यूशन ख़राब हो जाता है, तो वह नकारात्मक परिणाम उस मार्केटिंग दावे से अधिक मूल्यवान होता है, जो उसे प्रतिस्थापित करता है - एफएनओ साहित्य में कोई भी पेऑफ किंक के साथ विकल्पों का मूल्य निर्धारण नहीं कर रहा है।

यदि प्रयोग 1-4 नहीं चलाया जा सकता है, तो यह लेख शिप नहीं किया जाना चाहिए। उनके बिना जो बचता है वह किसी और के आईसीएलआर पेपर की एक अच्छी तरह से लिखी गई व्याख्या है।

वेनिला विकल्पों से परे

यह मानते हुए कि उपरोक्त एजेंडा माप के साथ संपर्क में रहता है, एफएनओ ढांचा स्वाभाविक रूप से अधिक जटिल उपकरणों तक फैला हुआ है:

अमेरिकी विकल्प: एक अतिरिक्त आउटपुट चैनल के रूप में एक प्रारंभिक अभ्यास सीमा जोड़ें। एफएनओ मूल्य सतह और इष्टतम व्यायाम सीमा दोनों को एक साथ सीखता है।
बैरियर विकल्प: बैरियर स्तरों को इनपुट चैनल के रूप में एनकोड करें। ध्यान दें कि एक बाधा एक दूसरा असंतोष है, और माप एजेंडा से गिब्स की चिंता अधिक बल के साथ लागू होती है, कम नहीं।
मल्टी-एसेट बास्केट: 2-3 अंडरलाइंग पर बास्केट विकल्पों के लिए 2डी या 3डी एफएनओ का उपयोग करें। आयामीता का अभिशाप ग्रिड-आधारित सॉल्वरों की तुलना में कम गंभीर है क्योंकि एफएनओ निश्चित संख्या में मोड पर काम करता है।
स्थानीय अस्थिरता: पूर्ण डुपायर स्थानीय अस्थिरता सतह इनपुट करें $\sigma_{\text{loc}}(S,t)$ एक स्थानिक कार्य के रूप में. यह ऑपरेटर सीखने के लिए सबसे स्वाभाविक उपयोग का मामला है - इनपुट एक फ़ंक्शन है, स्केलर पैरामीटर नहीं।

निष्कर्ष

फूरियर न्यूरल ऑपरेटर का योगदान कम्प्यूटेशनल होने से पहले वैचारिक है: एक समय में एक पीडीई को हल करने के बजाय, आप समाधान ऑपरेटर को स्वयं पैरामीटराइज़ करते हैं, और फूरियर स्पेस में ऐसा करने से एक आर्किटेक्चर प्राप्त होता है $O(n \log n)$ , निरंतर ऑपरेटरों पर सार्वभौमिक, और निर्माण द्वारा संकल्प-लचीला। यह बात ली एट अल से बहुत कुछ मिलती है। (2021) और उपरोक्त कोड से, जो चलता है।

जो चीज़ अनुसरण नहीं करती वह स्पीडअप नंबर है। साहित्य के 100x-1000x आंकड़े आधार रेखाओं के विरुद्ध तरल बेंचमार्क पर मापे जाते हैं जिनकी गुणवत्ता शायद ही कभी बताई जाती है, और इस श्रृंखला ने एक संपूर्ण लेख बिताया है जिसमें दिखाया गया है कि इस तरह के शीर्षक का कितना भाग आमतौर पर हार्डवेयर के बजाय एल्गोरिदम है। वे दावे जो एक ऑपरेटर को मूल्य निर्धारण इंजन में डालने को उचित ठहराते हैं - सेंट-लेवल एफपी 32 सटीकता, एक सीमित नो-आर्बिट्रेज उल्लंघन दर, सुपर-रिज़ॉल्यूशन जो एक पेऑफ किंक से बचता है, और एक * सक्षम * सीपीयू सॉल्वर के खिलाफ एक स्पीडअप वक्र - सभी मापने योग्य हैं, ब्लैक-स्कोल्स पर सभी सस्ते हैं क्योंकि बंद फॉर्म मौजूद है, और सभी अभी भी यहां अनमापे गए हैं।

इस मसौदे की यही स्थिति है: तंत्र वास्तविक है, वादा विश्वसनीय है, और साक्ष्य लंबित है।

संदर्भ और आगे पढ़ना:

ली, जेड., कोवाचकी, एन., अज़ीज़ाडेनेशेली, के., एट अल। "पैरामीट्रिक आंशिक विभेदक समीकरणों के लिए फूरियर न्यूरल ऑपरेटर।" आईसीएलआर 2021. arXiv:2010.08895
लू, एल., जिन, पी., पैंग, जी., झांग, जेड., और कर्णियाडाकिस, जी.ई. "डीपोनेट के माध्यम से नॉनलाइनियर ऑपरेटर्स सीखना।" नेचर मशीन इंटेलिजेंस, 2021। doi:10.1038/s42256-021-00302-5
ली, जेड, एट अल। "आंशिक विभेदक समीकरण सीखने के लिए भौतिकी-सूचित तंत्रिका संचालक।" एसीएम/आईएमएस जर्नल ऑफ डेटा साइंस, 2024। ओपनरिव्यू
neuraloperator PyTorch लाइब्रेरी: github.com/neuraloperator/neuraloperator
साल्वाडोर, एम., एट अल। "विकल्प मूल्य निर्धारण के लिए ब्लैक-स्कोल्स समीकरण का तंत्रिका नेटवर्क सीखना।" arXiv:2405.05780
बाई, वाई., एट अल. "एआई ब्लैक-स्कोल्स: फाइनेंस-इन्फ़ॉर्म्ड न्यूरल नेटवर्क।" arXiv:2412.12213