ตัวดำเนินการระบบประสาทฟูริเยร์สำหรับการสร้างแบบจำลองทางการเงินที่ใช้ PDE

จนถึงขณะนี้โครงข่ายประสาทเทียมทุกเครือข่ายในบล็อกนี้มี ฟังก์ชัน โดยประมาณ: คุณลักษณะเข้าและออก ตัวดำเนินการระบบประสาทฟูริเยร์ประมาณ ตัวดำเนินการ — แผนที่ระหว่างปริภูมิฟังก์ชันอนันต์ โดยที่อินพุตเป็นพื้นผิวที่มีความผันผวนทั้งหมด และเอาต์พุตเป็นพื้นผิวราคาทั้งหมด นั่นคือวัตถุที่แตกต่างกัน มันต้องการเครื่องจักรที่แตกต่างกัน และเครื่องจักรเป็นจุดสำคัญของบทความนี้: เคอร์เนลที่มีค่าเชิงซ้อนที่เรียนรู้ได้ซึ่งนำไปใช้กับโหมดฟูริเยร์ต่ำสุด ประเมินผ่านการเดินทางไปกลับ FFT ใน $O(n \log n)$.

การกำหนดราคาตัวเลือกคือจุดที่สิ่งนี้เกิดขึ้นในด้านการเงิน Black-Scholes, Heston, ความผันผวนในท้องถิ่น - PDE ทั้งหมดได้รับการแก้ไขแล้วในวันนี้ด้วยการตั้งค่าพารามิเตอร์ทีละรายการ ผู้ปฏิบัติงานเรียนรู้กลุ่มพารามิเตอร์ทั้งหมดพร้อมกัน และผลลัพธ์การส่งต่อที่ได้จะเป็นเคอร์เนล GPU ที่จัดเป็นชุดเดียว แทนที่จะเป็นไทม์มาร์ชชิ่งลูป

นั่นคือคำสัญญา บทความนี้ฉบับตรงไปตรงมาจะแยกกลไกซึ่งมีความแข็งแกร่งและสามารถทำซ้ำได้จากโค้ดด้านล่าง จากการกล่าวอ้างประสิทธิภาพ ซึ่งในวรรณกรรม FNO ได้รับการรายงานโดยเทียบกับพื้นฐานที่ไม่มีใครในซีรีส์นี้ยอมรับโดยไม่ได้รับการตรวจสอบ กลไกต้องมาก่อน วาระการวัดผลมาถึงตอนท้าย โดยทำเครื่องหมายว่ายังไม่ได้ดำเนินการ

จากการประมาณฟังก์ชันไปจนถึงการเรียนรู้ของผู้ปฏิบัติงาน

ฟังก์ชันโดยประมาณของโครงข่ายประสาทเทียมแบบคลาสสิก: ป้อนข้อมูลเข้า $x \in \mathbb{R}^n$พวกมันสร้างผลลัพธ์ $y \in \mathbb{R}^m$. นี่เป็นสิ่งที่ทรงพลัง แต่จะถูกจำกัดโดยพื้นฐานเมื่อวัตถุที่น่าสนใจนั้นทำงานได้ในตัวมันเอง ในการแก้ปัญหา PDE ทางการเงิน ข้อมูลเข้าไม่ใช่ตัวเลขตัวเดียว แต่เป็นฟังก์ชันที่อธิบายเงื่อนไขเริ่มต้น/ขอบเขต พื้นผิวความผันผวน หรือโครงสร้างคำศัพท์ ผลลัพธ์เป็นอีกฟังก์ชันหนึ่ง: ราคาที่อยู่เหนือระดับ $(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)$.

สถาปัตยกรรมสองแห่งมีอิทธิพลเหนือภูมิทัศน์การเรียนรู้ของผู้ปฏิบัติงาน:

1. DeepONet (Lu et al., 2021): ใช้เครือข่ายสาขาเพื่อเข้ารหัสฟังก์ชันอินพุต และใช้เครือข่าย Trunk เพื่อเข้ารหัสตำแหน่งการสืบค้น ผลลัพธ์คือผลิตภัณฑ์ภายในของพวกเขา มีพื้นฐานมาจากทฤษฎีบทการประมาณสากลสำหรับตัวดำเนินการโดย Chen และ Chen (1995)

2. Fourier Neural Operator (Li et al., 2021): กำหนดพารามิเตอร์ของเคอร์เนลอินทิกรัลในพื้นที่ฟูริเยร์ โดยใช้ FFT เพื่อการหมุนเวียนทั่วโลกที่มีประสิทธิภาพ ความละเอียดคงที่โดยการก่อสร้าง

ทั้งสองแบบเป็นตัวประมาณแบบสากลสำหรับผู้ปฏิบัติงานต่อเนื่อง แต่ FNO มีข้อได้เปรียบทางโครงสร้างสำหรับปัญหา PDE: ความลำเอียงทางสเปกตรัมของมันจะจับโครงสร้างโซลูชัน PDE ทั่วโลกที่ราบรื่นโดยธรรมชาติ นอกจากนี้ยังมี ข้อเสีย โครงสร้างสำหรับการจ่ายผลตอบแทนออปชั่นโดยเฉพาะ ซึ่งเราจะกลับมาใช้อีกครั้ง — พื้นฐานฟูริเยร์ที่ถูกตัดทอนและการหักงอเมื่อนัดหยุดงานไม่ใช่พันธมิตรโดยธรรมชาติ

สถาปัตยกรรม FNO ในรายละเอียด

ตัวดำเนินการประสาทฟูริเยร์แนะนำโดย Li และคณะ ที่ ICLR 2021 สร้างจากการสังเกตที่เรียบง่ายแต่ทรงพลัง: ฟังก์ชันของ Green (เคอร์เนลอินทิกรัล) ของ PDE จำนวนมากมีการแสดงที่กะทัดรัดในปริภูมิฟูริเยร์ แทนที่จะเรียนรู้เคอร์เนลในพื้นที่ทางกายภาพซึ่งจำเป็น $O(n^2)$ พารามิเตอร์สำหรับ $n$ จุดกริด — FNO เรียนรู้ในพื้นที่ความถี่โดยมีค่าต่ำสุดเท่านั้น $k_{\max}$ โหมดลดความซับซ้อนให้กับ $O(n \log n)$ ผ่านทาง FFT

สถาปัตยกรรมวนซ้ำ

FNO ประกอบด้วย:

1. ชั้นยกกระชับ $P$: แผนที่เชิงเส้นตรงจุดที่ฉายอินพุตจากมิติช่องสัญญาณดั้งเดิมไปจนถึงการแสดงค่าแฝงในมิติที่สูงกว่า: $v_0(x) = P(a(x))$.

2. ชั้นฟูเรียร์ (ซ้ำ $L$ ครั้ง): แต่ละชั้นใช้:

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

ที่ไหน $W_l$ คือการแปลงเชิงเส้นเฉพาะที่ (pointwise $1 \times 1$ การบิด) และ $\mathcal{K}_l$ เป็นผู้ดำเนินการครบวงจรระดับโลกที่ดำเนินการผ่าน FFT:

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

ที่นี่ $\mathcal{F}$ หมายถึง FFT $R_l$ เป็นเทนเซอร์ตุ้มน้ำหนักมูลค่าเชิงซ้อนที่เรียนรู้ได้ซึ่งนำไปใช้กับค่าต่ำสุด $k_{\max}$ โหมดฟูริเยร์และ $\sigma$ เป็นการเปิดใช้งานแบบไม่เชิงเส้นตามจุด (โดยทั่วไปคือ GELU)

3. ชั้นฉายภาพ $Q$: แมปการแสดงค่าแฝงกลับไปยังมิติเอาต์พุต: $u(x) = Q(v_L(x))$.

ทำไมต้องฟูเรียร์สเปซ?

การบิดสเปกตรัม $R_l \cdot \mathcal{F}(v_l)$ คือการคูณในโดเมนความถี่ ซึ่งเทียบเท่ากับการบิดของโลกในปริภูมิทางกายภาพ แต่คำนวณแล้ว $O(n \log n)$ แทน $O(n^2)$. นี่ไม่ใช่แค่เคล็ดลับด้านประสิทธิภาพเท่านั้น โดยทั่วไปโซลูชัน PDE จะราบรื่นและโดดเด่นด้วยส่วนประกอบความถี่ต่ำ โดยการตัดทอนเป็น $k_{\max}$ โหมด FNO จะทำหน้าที่เป็นตัวกรองความถี่ต่ำผ่านที่เรียนรู้ได้ ซึ่งจะทำให้โซลูชันเป็นปกติตามธรรมชาติและหลีกเลี่ยงสิ่งรบกวนความถี่สูง

สิ่งสำคัญที่สุดคือ FNO ถูกอ้างว่าเป็น discretization-invariant: เมื่อได้รับการฝึกฝนบนตารางขนาด $n$ก็สามารถประเมินได้ทุกความละเอียด $m \neq n$ โดยเพียงแค่ปรับขนาด FFT และช่องว่างภายในเป็นศูนย์หรือตัดทอนน้ำหนักสเปกตรัม คุณสมบัติความละเอียดสูงพิเศษแบบช็อตเป็นศูนย์นี้มีเอกลักษณ์เฉพาะในหมู่นักแก้ปัญหา PDE ของระบบประสาท และเป็นการกล่าวอ้างครั้งแรกในบทความนี้ที่สมควรได้รับการวัดผลมากกว่าการอ้างอิง ดูวาระการวัดผลด้านล่าง

PDE เรากำลังเรียนรู้จากผู้ปฏิบัติงาน

Black-Scholes PDE — ได้มา แบ่งแยกเป็นระยะๆ และกำหนดด้วยโซลูชันการเรียก/วางในรูปแบบปิดใน The Black-Scholes Formula — คือเป้าหมายของผู้ปฏิบัติงาน:

$\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 ราคาที่แน่นอน ซึ่งแทบไม่มีเกณฑ์มาตรฐาน FNO ในวรรณกรรมสามารถทำได้

สูตร FNO

เราตั้งปัญหาใหม่เป็นการเรียนรู้จากผู้ปฏิบัติงาน กำหนด:

• ฟังก์ชันอินพุต $a(S, t)$: เข้ารหัสพารามิเตอร์ PDE ซึ่งอาจรวมถึงพื้นผิวที่มีความผันผวนด้วย $\sigma(S, t)$ฟังก์ชันผลตอบแทน และอัตราปลอดความเสี่ยงตามช่องสัญญาณที่ซ้อนกันบน $(S, t)$ ตาราง
• ฟังก์ชันเอาท์พุต $u(S, t) = V(S, t)$: พื้นผิวราคาออปชั่น

FNO เรียนรู้ $\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)

    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

สำหรับการฝึกอบรม เราจะสุ่มตัวอย่างการกำหนดค่าพารามิเตอร์หลายพันรายการ — แตกต่างกันไป $\sigma \in [0.05, 0.80]$, $r \in [0.01, 0.10]$, $K \in [50, 150]$, $T \in [0.1, 2.0]$ — และแก้โจทย์แต่ละข้อด้วยวิธีผลต่างอันจำกัด ชุดข้อมูลผลลัพธ์ของคู่อินพุต-เอาต์พุตคือสิ่งที่ FNO เรียนรู้จาก

การขยายขนาด: แบบจำลองความผันผวนของ Heston Stochastic

ความผันผวนอย่างต่อเนื่องเป็นข้อสันนิษฐานที่ทราบกันดีอยู่แล้วว่าเป็นข้อเท็จ และเหตุใดจึงล้มเหลว เช่น รอยยิ้ม หางอ้วน เป็นเรื่องของหัวข้อ "ความเป็นจริงที่รุนแรง" ของ The Black-Scholes Formula Heston แก้ไขมันโดยทำให้ความแปรปรวนเป็นตัวแปรสถานะที่สอง:

$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$. PDE ที่สอดคล้องกันสำหรับราคาออปชั่น $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 มิติของ Heston PDE ยังแมปโดยตรงไปยัง 2D FFT ในเลเยอร์ฟูริเยร์ ดังนั้นสถาปัตยกรรมด้านล่างจึงสรุปโดยมีการเปลี่ยนแปลงมิติมากกว่าการออกแบบใหม่

FNO สำหรับการกำหนดราคาตัวเลือก: การใช้งาน PyTorch

ด้านล่างนี้คือการใช้งาน FNO ที่สมบูรณ์ในตัวเองสำหรับการเรียนรู้ผู้ปฏิบัติงาน Black-Scholes สถาปัตยกรรมเป็นไปตาม Li et al (2564) พร้อมการปรับตัวให้เข้ากับสภาพแวดล้อมทางการเงิน

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)

ห่วงการฝึกอบรม

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

การอนุมาน: ราคาแบบเรียลไทม์

@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 กับ PINN: การเปรียบเทียบเชิงปฏิบัติ

โครงข่ายประสาทเทียมที่ได้รับข้อมูลจากฟิสิกส์และตัวดำเนินการประสาทเทียมแบบฟูริเยร์เป็นตัวแทนของปรัชญาที่แตกต่างกันโดยพื้นฐานสำหรับการแก้ปัญหา PDE ด้วยโครงข่ายประสาทเทียม การทำความเข้าใจข้อดีข้อเสียคือเหตุผลเชิงปฏิบัติในการใส่ใจการเรียนรู้ของผู้ปฏิบัติงานเลย

PINN: การเพิ่มประสิทธิภาพต่ออินสแตนซ์

PINN วาง PDE ที่เหลือโดยตรงในการสูญเสีย — ปัญหา Navier-Stokes ครอบคลุมกลไก การแบ่งอัตโนมัติ physics_loss การใช้งานและผลการค้นหาภาวะเอกฐานของ DeepMind คุณสมบัติเดียวที่สำคัญที่นี่คือโครงสร้าง: PINN ได้รับการฝึกฝนต่อชุดพารามิเตอร์ การเปลี่ยนแปลง $\sigma$, $r$, $K$ หรือ $T$ และคุณเพิ่มประสิทธิภาพอีกครั้งตั้งแต่ต้น

จุดแข็ง: ไม่จำเป็นต้องมีข้อมูลที่มีป้ายกำกับ บังคับใช้โครงสร้าง PDE โดยตรง ใช้งานได้กับ PDE ใดๆ ที่คุณสามารถจดบันทึกได้

จุดอ่อน: ต้องฝึกใหม่สำหรับชุดพารามิเตอร์ใหม่แต่ละชุด $(\sigma, r, K, T)$. การฝึกอบรมเกี่ยวข้องกับการปรับสมดุลเงื่อนไขการสูญเสียหลายรายการ (PDE คงเหลือ เงื่อนไขขอบเขต เงื่อนไขเริ่มต้น) ซึ่งมักจะนำไปสู่พยาธิสภาพของการเพิ่มประสิทธิภาพ การบรรจบกันอาจเกิดขึ้นได้ช้า โดยทั่วไปจะมีขั้นตอนการไล่ระดับสี 10,000–100,000 ขั้นต่ออินสแตนซ์ของปัญหา ล้มเหลวในระบบหลายขนาดและวุ่นวาย ซึ่งภูมิทัศน์การสูญเสียกลายเป็นแบบไม่นูนสูง

FNO: การเรียนรู้ของผู้ดำเนินการตัดจำหน่าย

FNO เรียนรู้ตัวดำเนินการโซลูชันจากข้อมูล ต้องใช้ชุดข้อมูลการฝึกที่สร้างโดยตัวแก้แบบคลาสสิก แต่เมื่อฝึกแล้ว ก็จะสรุปทั่วทั้งพื้นที่พารามิเตอร์ทั้งหมด

จุดแข็ง: การอนุมานต่ำกว่ามิลลิวินาทีในการวัดประสิทธิภาพที่เผยแพร่ สรุปพารามิเตอร์ที่มองไม่เห็นโดยไม่ต้องฝึกใหม่ ความละเอียดคงที่ — ฝึกที่ความละเอียดต่ำ ประเมินที่ความละเอียดสูง จัดการโซลูชัน PDE ที่ราบรื่นอย่างเป็นธรรมชาติผ่านสเปกตรัมไบแอส

จุดอ่อน: ต้องการข้อมูลการฝึกอบรมจากนักแก้ปัญหาแบบคลาสสิก (ปัญหาไก่กับไข่สำหรับ PDE ที่แปลกใหม่อย่างแท้จริง) ข้อผิดพลาดในการประมาณมีขอบเขตแต่ไม่เป็นศูนย์ ตีความได้น้อยกว่าแนวทางที่จำกัดโดย PDE และความลำเอียงทางสเปกตรัมที่ช่วยในการแก้ปัญหาที่ราบรื่นคือความรับผิดที่ผลตอบแทนที่ผิดเพี้ยน

การเปรียบเทียบแบบตัวต่อตัว

ตารางด้านล่างนี้ รายงานโดยวรรณกรรม ไม่ได้วัดที่นี่ — แถวความแม่นยำและการเร่งความเร็วโดยเฉพาะมาจาก Li et al (2021) และงานติดตามผลเกี่ยวกับการวัดประสิทธิภาพที่ลื่นไหล ไม่ใช่จากการกำหนดราคาตัวเลือกบนฮาร์ดแวร์ของเรา อ่านแถวโครงสร้าง (ข้อมูลที่จำเป็น ลักษณะทั่วไป ความแปรปรวนของการแก้ไข) เป็นแถวที่เชื่อถือได้

ไฮบริด: ตัวดำเนินการประสาทที่ได้รับข้อมูลจากฟิสิกส์ (PINO)

PINO (Li et al., 2024) รวมทั้งสองแนวทางเข้าด้วยกัน ใช้สถาปัตยกรรม FNO แต่เพิ่มการสูญเสียที่ขับเคลื่อนด้วยข้อมูลด้วยระยะเวลาคงเหลือของ PDE:

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

การสลายตัวเป็นส่วนที่มีประโยชน์ $\mathcal{L}_{\text{data}}$ ยึดตัวดำเนินการเพื่อแก้ปัญหาเอาต์พุตทุกที่ที่คุณมี $\lambda \mathcal{L}_{\text{PDE}}$ จำกัดทุกที่ที่คุณไม่ทำ รวมถึงขอบเขตของพื้นที่พารามิเตอร์ที่คุณไม่เคยสุ่มตัวอย่าง สำหรับการกำหนดราคาออปชั่นระยะที่สองนั้นน่าสนใจด้วยเหตุผลเฉพาะทางการเงิน: PDE คงเหลือเป็นข้อจำกัด ยาก คุณสามารถประเมิน ณ เวลาอนุมานเป็นการตรวจสอบตัวเอง ซึ่งเป็นพื้นฐานของทางเลือกในการตรวจสอบคงเหลือด้านล่าง

ข้อควรพิจารณาเชิงปฏิบัติสำหรับการปรับใช้การผลิต

ครึ่งหนึ่งของสิ่งนี้โดยทั่วไป ได้แก่ งบประมาณเวลาแฝงในการอนุมาน การสร้างไปป์ไลน์ข้อมูล การตรวจสอบการเบี่ยงเบน การฝึกซ้ำเป็นระยะ ได้รับการครอบคลุมอยู่แล้วสำหรับโมเดลประสาทในระบบการซื้อขายในส่วนการผลิตของ DeepLOB: Deep Learning on Limit Order Books และจะนำไปใช้โดยไม่มีการเปลี่ยนแปลง สิ่งต่อไปนี้เป็นเพียงสิ่งที่เฉพาะเจาะจงสำหรับตัวดำเนินการเท่านั้น

ไปป์ไลน์ข้อมูล: การสุ่มตัวอย่างพื้นที่พารามิเตอร์

การสร้างข้อมูลการฝึกอบรมถือเป็นปัญหาคอขวดหลัก และไม่เหมือนกับโมเดลข้อมูลตลาด คุณเลือกการกระจายข้อมูลของคุณเอง ซึ่งหมายความว่าคุณอาจทำผิดในลักษณะที่มองไม่เห็นในการสูญเสีย สำหรับผู้ปฏิบัติงาน Black-Scholes ที่มี 4 พารามิเตอร์ ตัวอย่าง 5,000–10,000 รายการก็เพียงพอแล้ว สำหรับ Heston ที่มี 5 พารามิเตอร์บวกโดเมนเชิงพื้นที่ 2 มิติ โดยทั่วไปจะมีตัวอย่าง 20,000–50,000 ตัวอย่าง ใช้การสุ่มตัวอย่างแบบปรับได้: รวมกลุ่มตัวอย่างไว้ในพื้นที่พารามิเตอร์ที่โซลูชันเปลี่ยนแปลงอย่างรวดเร็ว — ใกล้ได้เงิน, ครบกำหนดสั้น, มีความผันผวนสูง — เนื่องจากการสุ่มตัวอย่างแบบสม่ำเสมอของกล่องใช้งบประมาณส่วนใหญ่ในภูมิภาค Deep-ITM และ Deep-OTM ซึ่งผู้ปฏิบัติงานเกือบจะเป็นเส้นตรงและเรียนรู้ได้ดีจากตัวอย่างเพียงไม่กี่ตัวอย่าง

การปรับแต่งสถาปัตยกรรม

• โหมด ($k_{\max}$): เริ่มด้วย $N/4$ ที่ไหน $N$ คือขนาดกริดเชิงพื้นที่ สำหรับ $N=256$ให้ใช้โหมด 32–64 มีโหมดน้อยเกินไปที่สูญเสียรายละเอียดใกล้กับขอบเขตการโจมตี มีเสียงรบกวนมากเกินไป
• เลเยอร์: 4 ฟูเรียร์เลเยอร์เป็นมาตรฐาน เครือข่ายที่ลึกกว่า (6–8) ช่วยแก้ปัญหา 2 มิติ เช่น Heston แต่เพิ่มหน่วยความจำ
• ช่องที่ซ่อนอยู่: 64 สำหรับ 1D Black-Scholes, 128 สำหรับ 2D Heston ปรับขนาดด้วยความซับซ้อนของปัญหา

ความแม่นยำ: คำถาม fp32

SpectralConv1d จัดสรร torch.cfloat — คอมเพล็กซ์ความแม่นยำเดียว — และ FFT ไปกลับทุกครั้งจะทำงานด้วยความแม่นยำนั้น บล็อกนี้ได้เห็นไปป์ไลน์ทางการเงินของ fp32 ส่งคืนขยะเงียบๆ ใน The GPU Precision Trap ซึ่งสูตรการคำนวณผลรวมคำนำหน้าที่ถูกต้องทางคณิตศาสตร์สูญเสียไปอย่างหายนะที่ขนาด fp32 คำถามที่คล้ายกันคือตรง: ที่ $S \approx 100$ ด้วยราคาที่เสนอเป็นเปอร์เซ็นต์ fp32 spectral ไปกลับถือได้หรือไม่ $10^{-2}$ สัมบูรณ์ หรือการเติบโตระดับกลางของ FFT กินเลขนัยสำคัญสุดท้ายหรือไม่

การควบคุมข้อผิดพลาด

สำหรับการกำหนดราคาตัวเลือกการผลิต คุณต้องมีขอบเขตข้อผิดพลาดที่คุณสามารถป้องกันได้

1. ความไม่แน่นอนที่ปรับเทียบแล้ว: ค่าเบี่ยงเบนมาตรฐานทั้งมวล ไม่ใช่ การรับประกันความครอบคลุม และบล็อกนี้มีกลไกที่จะทำอย่างถูกต้อง — แบ่งตามโครงสร้างบนตารางพารามิเตอร์ที่ถือไว้ โดยมี ACI/DtACI สำหรับกรณีที่ไม่สามารถแลกเปลี่ยนได้ใน Conformal Prediction for Risk-Aware Position Sizing การห่อ FNO ในลักษณะแยกส่วนเหนือ $(\sigma, r, K, T)$ ตารางให้ช่วงราคาที่ไม่มีการแจกแจง
2. การตรวจสอบสารตกค้าง: คำนวณ PDE ที่ตกค้างของการทำนาย FNO เป็นการตรวจสอบหลังการดำเนินการ ถ้า $\|\text{residual}\| > \epsilon$ให้กลับไปใช้ตัวแก้แบบคลาสสิก ซึ่งไม่มีค่าใช้จ่ายใดๆ ในการอนุมาน — ส่วนที่เหลือคือสเตนซิลผลต่างอันจำกัดบนอาร์เรย์ที่คุณมีอยู่แล้ว
3. การเรียนรู้เชิงรุก: กำหนดเส้นทางอินพุตที่มีความไม่แน่นอนสูงไปยังตัวแก้แบบคลาสสิก เพิ่มผลลัพธ์ไปยังชุดการฝึก และฝึกใหม่เป็นระยะ ความกว้างของช่วงเวลาตามรูปแบบจาก (1) คือสัญญาณการกำหนดเส้นทางตามธรรมชาติ

วาระการวัดผล

นี่คือส่วนที่ตัดสินใจว่าสถาปัตยกรรมข้างต้นคุ้มค่าที่จะนำไปใช้หรือไม่ และยังไม่มีการดำเนินการใดเสร็จสิ้น มีการระบุไว้ที่นี่แทนที่จะฝังไว้เพราะทางเลือกอื่น - การยืนยันการเร่งความเร็วพาดหัว - คือการลงทะเบียนบล็อกนี้มีอยู่เพื่อหลีกเลี่ยง

1. การเร่งความเร็วเป็นเส้นโค้ง ไม่ใช่ตัวเลข When the GPU Pays Off สร้างรูปร่าง: $S(B) = aB/(O + bB)$เพิ่มขึ้นจากการครอบงำเหนือศีรษะที่ $B=1$ ไปยังที่ราบสูงที่มีขอบเขตในการคำนวณ และแสดงพาดหัว 167x แยกย่อยเป็น 27x ของอัลกอริทึมคูณ 6.2x ของฮาร์ดแวร์ การวัด FNO ต้องเป็นไปตามแม่แบบนั้น: นาฬิกาแขวนที่ส่งต่อที่ $B \in \{1, 8, 64, 512\}$ และรายงานโค้งทั้งหมด ในเชิงวิกฤตนั้น เส้นฐานจะต้องเป็นตัวแก้ผลต่างอันจำกัดแบบ vectorized, multi-core — black_scholes_fd ด้านบนเป็น double loop ที่ตีความ ซึ่งเป็นบรรทัดฐาน "การใช้งาน CPU ที่แย่ที่สุด" ที่แน่นอนในชื่อบทความ และการเปรียบเทียบตัวดำเนินการ GPU แบบแบตช์กับมันจะสร้างตัวเลขที่ไม่มีความหมายอะไรเลย

2. ความแม่นยำเทียบกับรูปแบบปิด นี่คือการทดลองที่ Black-Scholes ทำให้เกือบเป็นอิสระ และการวัดประสิทธิภาพเชิงพลศาสตร์ของไหลไม่สามารถทำได้เลย: ฝึกกับข้อมูลที่สร้างโดย FD แล้วให้คะแนนเทียบกับค่าที่แน่นอน norm.cdf ราคาทั่วทั้ง $(\sigma, r, K, T)$ กล่อง. แจ้งญาติ $L^2$และรายงานข้อผิดพลาด การกระจาย — โดยเฉพาะเมื่อใกล้ถึงจุดหยุดงานและใกล้หมดอายุ ซึ่งการแก้ปัญหามีความราบรื่นน้อยที่สุดและพื้นฐานสเปกตรัมที่ถูกตัดทอนควรประสบปัญหามากที่สุด

3. ไม่มีการละเมิดการเก็งกำไร ผู้ปฏิบัติงานที่เรียนรู้ไม่มีเหตุผลเชิงโครงสร้างที่จะเคารพข้อจำกัดด้านรูปทรงที่พื้นผิวราคาต้องเป็นไปตาม: ความซ้ำซากจำเจใน $K$,นูนเข้า $K$, และ $V \geq \max(S-K, 0)$. การวัดอัตราการละเมิดในช่องพารามิเตอร์จะเปลี่ยนคำถามเปิดของบทความนี้ — เราสามารถรับประกันเงื่อนไขที่ไม่มีการเก็งกำไรในตัวดำเนินการที่เรียนรู้ได้หรือไม่ — จากการโบกมือเป็นตัวเลข

4. Discretization invariance ทดสอบมากกว่ายืนยัน ฝึกที่ $N_S = 128$,ประเมินที่ $N_S = 512$, รายงานข้อผิดพลาด. โหมดความล้มเหลวที่คาดหวังได้รับการตั้งชื่อและเฉพาะเจาะจง: กิ๊บส์ส่งเสียงกริ่ง $\max(S-K, 0)$. พื้นฐานฟูริเยร์ที่ถูกตัดทอนจะสร้างฟังก์ชันขึ้นใหม่โดยมีอนุพันธ์อันดับหนึ่งที่ไม่ต่อเนื่องจะแกว่งไปมารอบๆ และความละเอียดพิเศษแบบช็อตเป็นศูนย์อาจทำให้สิ่งนั้นแย่ลงมากกว่าดีกว่าด้วยการเปิดเผยโหมดต่างๆ ที่ความละเอียดในการฝึกไม่เคยเห็นมาก่อน หากความละเอียดขั้นสูงลดลงใกล้การประท้วง ผลลัพธ์เชิงลบนั้นจะมีค่ามากกว่าคำกล่าวอ้างทางการตลาดที่จะถูกแทนที่ — ไม่มีใครในวรรณกรรม FNO ที่มีตัวเลือกการกำหนดราคาที่มีข้อเสียด้านผลตอบแทน

หากไม่สามารถดำเนินการทดลอง 1–4 ได้ ไม่ควรจัดส่งบทความนี้ สิ่งที่เหลืออยู่หากไม่มีสิ่งเหล่านี้ก็คือการอธิบายรายงาน ICLR ของผู้อื่นที่เขียนไว้อย่างดี

นอกเหนือจากตัวเลือกวานิลลา

สมมติว่าวาระข้างต้นยังคงอยู่จากการติดต่อกับการวัดผล กรอบงาน FNO จะขยายไปสู่เครื่องมือที่ซับซ้อนมากขึ้นอย่างเป็นธรรมชาติ:

• ตัวเลือกแบบอเมริกัน: เพิ่มขอบเขตการออกกำลังกายตั้งแต่เนิ่นๆ เป็นช่องทางเอาท์พุตเพิ่มเติม FNO เรียนรู้ทั้งพื้นผิวราคาและขอบเขตการใช้สิทธิที่เหมาะสมที่สุดไปพร้อมๆ กัน
• ตัวเลือกสิ่งกีดขวาง: เข้ารหัสระดับสิ่งกีดขวางเป็นช่องสัญญาณอินพุต โปรดทราบว่าอุปสรรคคือความไม่ต่อเนื่องครั้งที่สอง และข้อกังวลของ Gibbs จากวาระการวัดผลมีผลบังคับมากกว่าไม่น้อย
• ตะกร้าหลายสินทรัพย์: ใช้ 2D หรือ 3D FNO สำหรับตัวเลือกตะกร้าบนพื้นฐาน 2-3 รายการ คำสาปแห่งมิตินั้นมีความรุนแรงน้อยกว่าสำหรับตัวแก้ปัญหาแบบกริด เนื่องจาก FNO ทำงานในโหมดจำนวนคงที่
• ความผันผวนในท้องถิ่น: ป้อนค่าพื้นผิวความผันผวนในท้องถิ่นของ Dupire แบบเต็ม $\sigma_{\text{loc}}(S,t)$ เป็นฟังก์ชันเชิงพื้นที่ นี่เป็นกรณีการใช้งานที่เป็นธรรมชาติที่สุดสำหรับการเรียนรู้ของผู้ปฏิบัติงาน — อินพุต คือ ฟังก์ชัน ไม่ใช่พารามิเตอร์สเกลาร์

บทสรุป

การมีส่วนร่วมของ Fourier Neural Operator นั้นเป็นแนวคิดก่อนที่จะมีการคำนวณ: แทนที่จะแก้ PDE ครั้งละหนึ่งตัว คุณจะกำหนดพารามิเตอร์ตัวดำเนินการโซลูชันเอง และการทำเช่นนี้ในพื้นที่ฟูริเยร์จะทำให้ได้สถาปัตยกรรมที่ $O(n \log n)$, เป็นสากลสำหรับผู้ปฏิบัติงานที่ต่อเนื่อง และความละเอียดที่ยืดหยุ่นโดยการก่อสร้าง นั่นตามมามากจาก Li และคณะ (2021) และจากโค้ดด้านบนซึ่งรันอยู่

สิ่งที่ไม่ตามมาคือเลขเร่ง ตัวเลข 100x–1000x ของวรรณกรรมวัดจากเกณฑ์มาตรฐานแบบไหลเทียบกับเส้นพื้นฐานซึ่งไม่ค่อยมีการกล่าวถึงคุณภาพ และซีรีส์นี้ใช้เวลาทั้งบทความเพื่อแสดงให้เห็นว่าพาดหัวดังกล่าวมักจะเป็นอัลกอริธึมมากกว่าฮาร์ดแวร์ คำกล่าวอ้างที่จะพิสูจน์ให้เห็นถึงการวางผู้ดำเนินการในกลไกการกำหนดราคา — ความแม่นยำ fp32 ระดับเซ็นต์, อัตราการละเมิดที่ไม่มีการเก็งกำไรแบบมีขอบเขต, ความละเอียดขั้นสูงที่รอดพ้นจากข้อผิดพลาดด้านผลตอบแทน และเส้นโค้งการเร่งความเร็วเมื่อเทียบกับตัวแก้ปัญหา CPU ที่ มีความสามารถ ล้วนสามารถวัดผลได้ ทั้งหมดนี้ราคาถูกบน Black-Scholes เนื่องจากมีแบบฟอร์มปิดอยู่ และทั้งหมดนี้ยังไม่ได้วัดผลที่นี่

นั่นคือสถานะของร่างนี้: กลไกนั้นมีจริง คำสัญญานั้นเป็นไปได้ และหลักฐานอยู่ในระหว่างการพิจารณา

ข้อมูลอ้างอิงและอ่านเพิ่มเติม:

• Li, Z., Kovachki, N., Azizzadenesheli, K. และคณะ "ตัวดำเนินการประสาทฟูริเยร์สำหรับสมการเชิงอนุพันธ์ย่อยพาราเมตริก" ICLR 2021 arXiv:2010.08895
• Lu, L., Jin, P., Pang, G., Zhang, Z., & Karniadakis, G.E. "การเรียนรู้ตัวดำเนินการไม่เชิงเส้นผ่าน DeepONet" หน่วยสืบราชการลับของเครื่องจักรธรรมชาติ 2021 doi:10.1038/s42256-021-00302-5
• Li, Z. และคณะ "ผู้ดำเนินการประสาทตามหลักฟิสิกส์เพื่อการเรียนรู้สมการเชิงอนุพันธ์ย่อยบางส่วน" ACM/IMS Journal of Data Science, 2024. OpenReview
• neuraloperator ห้องสมุด PyTorch: github.com/neuraloperator/neuraloperator
• ซัลวาดอร์ เอ็ม. และคณะ "การเรียนรู้โครงข่ายประสาทเทียมของสมการ Black-Scholes สำหรับการกำหนดราคาตัวเลือก" arXiv:2405.05780
• ไป๋ Y. และคณะ "AI Black-Scholes: โครงข่ายประสาทเทียมที่ได้รับข้อมูลทางการเงิน" arXiv:2412.12213