Toán tử thần kinh Fourier cho mô hình tài chính dựa trên PDE

Mọi mạng lưới thần kinh trên blog này cho đến nay đều xấp xỉ một hàm: các tính năng vào, một số ra. Toán tử thần kinh Fourier xấp xỉ một toán tử — một bản đồ giữa các không gian hàm vô hạn chiều, trong đó đầu vào là toàn bộ bề mặt biến động và đầu ra là toàn bộ bề mặt giá. Đó là một đối tượng khác, nó cần máy móc khác và máy móc là điểm chính của bài viết này: một hạt nhân có giá trị phức tạp có thể học được áp dụng cho các chế độ Fourier thấp nhất, được đánh giá thông qua chuyến đi khứ hồi FFT trong $O(n \log n)$.

Định giá quyền chọn là nơi điều này xảy ra trong lĩnh vực tài chính. Black-Scholes, Heston, biến động cục bộ - tất cả các PDE, ngày nay đều giải quyết được một tham số được đặt tại một thời điểm. Người vận hành sẽ tìm hiểu toàn bộ họ tham số cùng một lúc và kết quả chuyển tiếp là một nhân GPU theo lô chứ không phải là một vòng lặp tuần tự thời gian.

Đó là lời hứa. Phiên bản trung thực của bài viết này tách biệt các cơ chế vững chắc và có thể tái tạo khỏi mã bên dưới khỏi các tuyên bố về hiệu suất mà trong tài liệu FNO được báo cáo dựa trên các đường cơ sở mà không ai trong loạt bài này chấp nhận nếu chưa được kiểm tra. Cơ khí là trên hết; chương trình đo lường nằm ở cuối, được đánh dấu là chưa chạy.

Từ xấp xỉ hàm đến học toán tử

Mạng nơ ron cổ điển có hàm gần đúng: cho trước một đầu vào $x \in \mathbb{R}^n$, họ tạo ra một đầu ra $y \in \mathbb{R}^m$. Điều này có tác dụng mạnh mẽ nhưng bị hạn chế về cơ bản khi bản thân các đối tượng quan tâm lại là các chức năng. Trong giải PDE tài chính, đầu vào không phải là một số duy nhất - nó là hàm mô tả các điều kiện ban đầu/giới hạn, bề mặt biến động hoặc cấu trúc thuật ngữ. Đầu ra là một chức năng khác: bề mặt giá trên $(S, t)$ không gian.

Học toán tử nâng vấn đề lên không gian vô hạn chiều. Thay vì học $f: \mathbb{R}^n \to \mathbb{R}^m$, chúng ta học một toán tử:

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

Ở đâu $\mathcal{A}$ Và $\mathcal{U}$ là không gian Banach của các hàm. Để định giá quyền chọn, $\mathcal{A}$ có thể là không gian của các bề mặt biến động $\sigma(S,t)$ Và $\mathcal{U}$ không gian của các bề mặt giá tương ứng $V(S,t)$.

Hai kiến trúc thống trị bối cảnh học tập của người vận hành:

1. DeepONet (Lu et al., 2021): Sử dụng mạng nhánh để mã hóa chức năng đầu vào và mạng trung kế để mã hóa vị trí truy vấn. Đầu ra là sản phẩm bên trong của họ. Dựa trên định lý xấp xỉ phổ quát cho các toán tử của Chen và Chen (1995).

2. Toán tử thần kinh Fourier (Li và cộng sự, 2021): Tham số hóa hạt nhân tích phân trong không gian Fourier, sử dụng FFT để tích chập toàn cục hiệu quả. Độ phân giải bất biến theo cách xây dựng.

Cả hai đều là các công cụ xấp xỉ phổ quát cho các toán tử liên tục, nhưng FNO có lợi thế về cấu trúc cho các bài toán PDE: độ lệch phổ của nó nắm bắt được cấu trúc toàn cục, trơn tru của các giải pháp PDE một cách tự nhiên. Nó cũng có một bất lợi về cấu trúc đối với các khoản hoàn trả tùy chọn cụ thể mà chúng ta sẽ quay lại - cơ sở Fourier bị cắt cụt và điểm gấp khúc khi thực hiện cú đánh không phải là đồng minh tự nhiên.

Kiến trúc FNO chi tiết

Toán tử thần kinh Fourier, được giới thiệu bởi Li et al. tại ICLR 2021, được xây dựng dựa trên một quan sát đơn giản nhưng mạnh mẽ: hàm Green (nhân tích phân) của nhiều PDE có biểu diễn nhỏ gọn trong không gian Fourier. Thay vì học một hạt nhân trong không gian vật lý — điều này đòi hỏi $O(n^2)$ thông số cho $n$ điểm lưới - FNO học nó trong không gian tần số chỉ với mức thấp nhất $k_{\max}$ các chế độ, giảm độ phức tạp xuống $O(n \log n)$ thông qua FFT.

Kiến trúc lặp

Một FNO bao gồm:

1. Lớp nâng $P$: Bản đồ tuyến tính theo từng điểm chiếu đầu vào từ thứ nguyên kênh ban đầu của nó sang biểu diễn tiềm ẩn có chiều cao hơn: $v_0(x) = P(a(x))$.

2. Lớp Fourier (lặp lại $L$ lần): Mỗi lớp áp dụng:

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

Ở đâu $W_l$ là một biến đổi tuyến tính cục bộ (theo điểm $1 \times 1$ tích chập) và $\mathcal{K}_l$ là toán tử tích phân toàn cục được triển khai thông qua FFT:

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

Đây $\mathcal{F}$ biểu thị FFT, $R_l$ là một tensor trọng số có giá trị phức có thể học được áp dụng cho mức thấp nhất $k_{\max}$ Các chế độ Fourier và $\sigma$ là một kích hoạt phi tuyến theo điểm (thường là GELU).

3. Lớp chiếu $Q$: Ánh xạ biểu diễn tiềm ẩn trở lại thứ nguyên đầu ra: $u(x) = Q(v_L(x))$.

Tại sao không gian Fourier?

Sự tích chập quang phổ $R_l \cdot \mathcal{F}(v_l)$ là phép nhân trong miền tần số, tương đương với tích chập toàn cục trong không gian vật lý - nhưng được tính theo $O(n \log n)$ thay vì $O(n^2)$. Đây không chỉ là một thủ thuật hiệu quả. Các giải pháp PDE thường trơn tru và bị chi phối bởi các thành phần tần số thấp. Bằng cách cắt ngắn thành $k_{\max}$ ở các chế độ, FNO hoạt động như một bộ lọc thông thấp có thể học được, điều chỉnh giải pháp một cách tự nhiên và tránh các tạo tác tần số cao.

Điều quan trọng là FNO được khẳng định là bất biến rời rạc: một khi được huấn luyện trên một lưới có kích thước $n$, nó có thể được đánh giá trên bất kỳ độ phân giải nào $m \neq n$ chỉ bằng cách điều chỉnh kích thước FFT và phần đệm bằng 0 hoặc cắt bớt trọng số quang phổ. Thuộc tính siêu phân giải không bắn này là duy nhất trong số các bộ giải PDE thần kinh - và đây là khẳng định đầu tiên trong bài viết này xứng đáng được đo lường hơn là một trích dẫn. Xem chương trình đo lường bên dưới.

PDE mà chúng tôi đang học toán tử

Black-Scholes PDE — được dẫn xuất, phân tích theo thuật ngữ và được đưa ra cùng với giải pháp gọi/đặt dạng đóng trong Công thức Black-Scholes — là mục tiêu của nhà điều hành:

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

Mọi thứ tiếp theo đều coi nó như một chiếc hộp đen với câu trả lời đã biết. Câu trả lời đã biết đó chính xác là lý do tại sao nó là trường hợp thử nghiệm phù hợp: một toán tử được đào tạo về đầu ra sai phân hữu hạn có thể được tính điểm dựa trên norm.cdf giá chính xác, điều mà hầu như không có tiêu chuẩn FNO nào trong tài liệu có thể làm được.

Công thức FNO

Chúng tôi viết lại vấn đề dưới dạng học toán. Xác định:

• Chức năng nhập $a(S, t)$: mã hóa các tham số PDE. Điều này có thể bao gồm bề mặt biến động $\sigma(S, t)$, hàm hoàn trả và lãi suất phi rủi ro khi các kênh được xếp chồng lên nhau trên $(S, t)$ lưới.
• Chức năng đầu ra $u(S, t) = V(S, t)$: bề mặt giá quyền chọn.

FNO học $\mathcal{G}_\theta: a \mapsto u$ từ một tập dữ liệu của $(a^{(i)}, u^{(i)})$ các cặp được tạo ra bởi một bộ giải truyền thống. Sau khi đào tạo, suy luận cho bất kỳ cấu hình tham số mới nào đều là một lần chuyển tiếp duy nhất.

Tạo dữ liệu đào tạo

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

Để đào tạo, chúng tôi lấy mẫu hàng nghìn cấu hình tham số — khác nhau $\sigma \in [0.05, 0.80]$, $r \in [0.01, 0.10]$, $K \in [50, 150]$, $T \in [0.1, 2.0]$ - và giải từng phương pháp sai phân hữu hạn. Tập dữ liệu kết quả của các cặp đầu vào-đầu ra là những gì FNO học được.

Mở rộng quy mô: Mô hình biến động ngẫu nhiên Heston

Sự biến động liên tục là một giả định đã biết là sai và tại sao nó thất bại — nụ cười, cái đuôi béo — là chủ đề của phần "Thực tế khắc nghiệt" của Công thức Black-Scholes. Heston sửa nó bằng cách biến phương sai thành biến trạng thái thứ hai:

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

với $\text{Corr}(dW_1, dW_2) = \rho$. PDE tương ứng cho giá quyền chọn $V(S, v, t)$ là hai chiều trong không gian:

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

Đây là nơi việc học của người vận hành có được thành công và lập luận mang tính cấu trúc hơn là thực nghiệm. Các sơ đồ sai phân hữu hạn trên một $(S, v, t)$ quy mô lưới như $O(N_S \times N_v \times N_t)$, số hạng đạo hàm chéo $\partial^2 V / \partial S \partial v$ làm phức tạp việc rời rạc hóa và mỗi tập tham số mới $(\kappa, \theta, \xi, \rho, r)$ thanh toán toàn bộ chi phí một lần nữa. Một nhà điều hành thanh toán một lần vào thời gian đào tạo. Cấu trúc không gian 2D của Heston PDE cũng ánh xạ trực tiếp lên FFT 2D trong các lớp Fourier, do đó kiến ​​trúc bên dưới khái quát hóa bằng sự thay đổi kích thước thay vì thiết kế lại.

FNO cho Định giá tùy chọn: Triển khai PyTorch

Dưới đây là cách triển khai FNO hoàn chỉnh, khép kín để học toán tử Black-Scholes. Kiến trúc theo Li et al. (2021) với những điều chỉnh phù hợp với bối cảnh tài chính.

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)

Vòng đào tạo

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

Suy luận: Định giá theo thời gian thực

@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 và PINN: So sánh thực tế

Mạng thần kinh dựa trên vật lý và Toán tử thần kinh Fourier thể hiện các triết lý khác nhau về cơ bản để giải quyết các PDE bằng mạng thần kinh. Hiểu được sự cân bằng của chúng là lý do thực tế để quan tâm đến việc học của người vận hành.

PINN: Tối ưu hóa theo phiên bản

PINN đặt phần dư PDE trực tiếp vào phần tổn thất — Vấn đề Navier-Stokes bao gồm cơ chế, tính năng tự động phân biệt physics_loss triển khai và kết quả tìm kiếm điểm kỳ dị DeepMind. Thuộc tính duy nhất quan trọng ở đây là cấu trúc: PINN được huấn luyện cho mỗi bộ tham số. Thay đổi $\sigma$, $r$, $K$ hoặc $T$ và bạn tối ưu hóa lại từ đầu.

Điểm mạnh: Không yêu cầu dữ liệu được gắn nhãn. Thực thi trực tiếp cấu trúc PDE. Hoạt động với mọi PDE mà bạn có thể viết ra.

Điểm yếu: Phải đào tạo lại cho từng bộ thông số mới $(\sigma, r, K, T)$. Việc đào tạo bao gồm việc cân bằng nhiều điều khoản tổn thất (dư lượng PDE, điều kiện biên, điều kiện ban đầu) thường dẫn đến các bệnh lý tối ưu hóa. Sự hội tụ có thể chậm - thường là 10.000–100.000 bước gradient cho mỗi trường hợp sự cố. Thất bại trên các hệ thống đa quy mô và hỗn loạn, nơi bối cảnh mất mát trở nên không lồi.

FNO: Học toán được khấu hao

FNO học toán tử giải pháp từ dữ liệu. Nó yêu cầu một tập dữ liệu huấn luyện được tạo bởi một bộ giải cổ điển, nhưng sau khi được huấn luyện, nó sẽ khái quát hóa trên toàn bộ không gian tham số.

Điểm mạnh: Suy luận dưới mili giây trong điểm chuẩn đã công bố. Tổng quát hóa các tham số chưa nhìn thấy mà không cần đào tạo lại. Độ phân giải bất biến - huấn luyện ở độ phân giải thấp, đánh giá ở độ phân giải cao. Xử lý các giải pháp PDE trơn tru một cách tự nhiên thông qua độ lệch quang phổ.

Điểm yếu: Yêu cầu dữ liệu huấn luyện từ một bộ giải cổ điển (bài toán con gà và quả trứng đối với các PDE thực sự mới lạ). Lỗi xấp xỉ bị giới hạn nhưng khác không. Ít giải thích hơn so với các phương pháp tiếp cận bị ràng buộc bởi PDE. Và độ lệch quang phổ giúp tạo ra các giải pháp trơn tru là một trách nhiệm đối với một nút thắt hoàn trả.

So sánh trực tiếp

Bảng bên dưới là được báo cáo theo tài liệu, không được đo lường ở đây - các hàng về độ chính xác và tốc độ nói riêng đến từ Li et al. (2021) và công việc tiếp theo dựa trên các điểm chuẩn linh hoạt, không phải từ việc định giá tùy chọn trên phần cứng của chúng tôi. Đọc các hàng cấu trúc (dữ liệu cần thiết, tổng quát hóa, độ phân giải bất biến) là những hàng đáng tin cậy.

| Tiêu chí | PINN | FNO | |----------||------|------| | Dữ liệu đào tạo cần thiết | Không có (không được giám sát) | Cặp do bộ giải tạo | | Chi phí suy luận | Đào tạo lại đầy đủ theo từng trường hợp | Chuyển tiếp đơn | | Khái quát hóa | Bộ tham số đơn | Toàn bộ họ tham số | | Độ phân giải bất biến | Không | Đã xác nhận là có - xem chương trình nghị sự bên dưới | | PDE đa quy mô | Thường thất bại | Báo cáo mạnh mẽ | | Độ chính xác (tương đối $L^2$, văn học) | $10^{-3}$ ĐẾN $10^{-2}$ | $10^{-4}$ ĐẾN $10^{-3}$ |

Sự kết hợp: Toán tử thần kinh dựa trên vật lý (PINO)

PINO (Li và cộng sự, 2024) kết hợp cả hai cách tiếp cận. Nó sử dụng kiến ​​trúc FNO nhưng làm tăng tổn thất do dữ liệu bằng thuật ngữ dư PDE:

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

Sự phân hủy là phần hữu ích. $\mathcal{L}_{\text{data}}$ gắn toán tử vào đầu ra của bộ giải ở bất cứ nơi nào bạn có; $\lambda \mathcal{L}_{\text{PDE}}$ ràng buộc nó ở mọi nơi bạn không làm, kể cả các vùng không gian tham số mà bạn chưa bao giờ lấy mẫu. Đối với việc định giá tùy chọn mà thuật ngữ thứ hai hấp dẫn vì một lý do cụ thể về tài chính: số dư PDE là một ràng buộc cứng, bạn cũng có thể đánh giá tại thời điểm suy luận dưới dạng tự kiểm tra, đây là cơ sở của dự phòng giám sát số dư bên dưới.

Những cân nhắc thực tế khi triển khai sản xuất

Phần chung của phần này — ngân sách độ trễ suy luận, xây dựng đường dẫn dữ liệu, giám sát độ lệch, đào tạo lại định kỳ — đã được đề cập đến cho mô hình thần kinh trong hệ thống giao dịch trong phần sản xuất của DeepLOB: Deep Learning on Limit Order Books và được áp dụng không thay đổi. Những gì sau đây chỉ là những gì dành riêng cho một nhà điều hành.

Đường ống dữ liệu: Lấy mẫu không gian tham số

Việc tạo dữ liệu đào tạo là nút thắt cổ chai chính và không giống như mô hình dữ liệu thị trường, bạn chọn phân phối của riêng mình - điều đó có nghĩa là bạn có thể mắc sai lầm theo cách không thể nhìn thấy được khi bị mất. Đối với toán tử Black-Scholes có 4 tham số, 5.000–10.000 mẫu là đủ. Đối với Heston với 5 tham số cộng với miền không gian 2D, 20.000–50.000 mẫu là điển hình. Sử dụng lấy mẫu thích ứng: tập trung mẫu vào các vùng tham số nơi giải pháp thay đổi nhanh chóng — gần đủ tiền, thời gian đáo hạn ngắn, độ biến động cao — vì việc lấy mẫu thống nhất của hộp dành phần lớn ngân sách cho các vùng ITM sâu và OTM sâu nơi người vận hành gần như tuyến tính và học tốt từ rất ít ví dụ.

Tinh chỉnh kiến trúc

• Chế độ ($k_{\max}$): Bắt đầu với $N/4$ Ở đâu $N$ là kích thước lưới không gian. Vì $N=256$, sử dụng chế độ 32–64. Quá ít chế độ bị mất chi tiết gần ranh giới tấn công; quá nhiều overfit để tiếng ồn.
• Lớp: 4 lớp Fourier là tiêu chuẩn. Mạng sâu hơn (6–8) giúp giải quyết các vấn đề 2D như Heston nhưng tăng bộ nhớ.
• Kênh ẩn: 64 cho 1D Black-Scholes, 128 cho 2D Heston. Mở rộng quy mô với độ phức tạp của vấn đề.

Độ chính xác: Câu hỏi của fp32

SpectralConv1d phân bổ torch.cfloat — phức hợp có độ chính xác đơn — và mọi chuyến đi khứ hồi FFT đều chạy ở độ chính xác đó. Blog này đã theo dõi một đường dẫn tài chính fp32 trả lại rác thầm lặng trong Bẫy chính xác GPU, trong đó công thức tổng tiền tố chính xác về mặt toán học bị mất một cách thảm hại ở cường độ fp32. Câu hỏi tương tự ở đây là trực tiếp: tại $S \approx 100$ với giá được tính theo xu, liệu chuyến đi khứ hồi quang phổ fp32 có giữ được không $10^{-2}$ tuyệt đối, hay mức tăng trưởng cường độ trung gian của FFT có ăn các chữ số có nghĩa cuối cùng không?

Kiểm soát lỗi

Để định giá tùy chọn sản xuất, bạn cần có giới hạn lỗi mà bạn có thể bảo vệ.

1. Độ không chắc chắn đã được hiệu chỉnh: độ lệch chuẩn tổng hợp không phải là sự đảm bảo về mức độ phù hợp và blog này có công cụ để thực hiện điều đó một cách chính xác — phân chia tuân thủ trên một lưới tham số được giữ lại, với ACI/DtACI cho trường hợp không thể trao đổi, trong Dự đoán phù hợp cho việc định cỡ vị thế nhận biết rủi ro. Bao bọc FNO theo kiểu phân chia phù hợp trên $(\sigma, r, K, T)$ lưới đưa ra các khoảng thời gian không phân phối trên giá.
2. Giám sát dư lượng: Tính toán dư lượng PDE của dự đoán FNO dưới dạng kiểm tra hậu kỳ. Nếu như $\|\text{residual}\| > \epsilon$, quay trở lại một bộ giải cổ điển. Điều này là miễn phí khi suy luận - phần dư là một khuôn mẫu sai phân hữu hạn trên một mảng mà bạn đã có.
3. Học tích cực: Định tuyến các đầu vào có độ không chắc chắn cao tới bộ giải cổ điển, thêm kết quả vào tập huấn luyện và đào tạo lại định kỳ. Độ rộng khoảng tuân thủ từ (1) là tín hiệu định tuyến tự nhiên.

Chương trình đo lường

Đây là phần quyết định xem kiến trúc trên có đáng để triển khai hay không và chưa có phần nào được thực hiện. Nó được liệt kê ở đây chứ không phải bị chôn vùi vì giải pháp thay thế - khẳng định tốc độ tiêu đề - chính xác là việc đăng ký mà blog này tồn tại để tránh.

1. Tăng tốc là một đường cong, không phải một con số. Khi GPU phát huy tác dụng thiết lập hình dạng: $S(B) = aB/(O + bB)$, tăng từ chi phí vượt trội tại $B=1$ đến một trạng thái ổn định được giới hạn bởi máy tính và nó hiển thị dòng tiêu đề gấp 167 lần được phân tách thành 27 lần thuật toán nhân với 6,2 lần phần cứng. Phép đo FNO phải tuân theo mẫu đó: đồng hồ treo tường chuyển tiếp tại $B \in \{1, 8, 64, 512\}$ và báo cáo toàn bộ đường cong. Về mặt quan trọng, đường cơ sở phải là một bộ giải sai phân hữu hạn được vector hóa, đa lõi — black_scholes_fd ở trên là một vòng lặp kép được diễn giải, đường cơ sở chính xác về "việc triển khai CPU tồi tệ nhất" mà bài viết nêu tên và việc so sánh toán tử GPU theo lô với nó sẽ tạo ra một con số chẳng có ý nghĩa gì.

2. Độ chính xác so với dạng đóng. Đây là thử nghiệm mà Black-Scholes thực hiện gần như miễn phí và các điểm chuẩn về động lực học chất lỏng hoàn toàn không thể thực hiện được: huấn luyện trên dữ liệu do FD tạo ra, sau đó tính điểm theo dữ liệu chính xác norm.cdf giá trên toàn $(\sigma, r, K, T)$ hộp. Khai báo người thân $L^2$và báo cáo lỗi phân phối - cụ thể là gần điểm đình công và gần hết hạn, trong đó giải pháp kém mượt mà nhất và cơ sở quang phổ bị cắt cụt sẽ gặp khó khăn nhiều nhất.

3. Vi phạm không có chênh lệch giá. Một toán tử có học thức không có lý do cấu trúc nào để tôn trọng các ràng buộc về hình dạng mà bề mặt giá phải thỏa mãn: tính đơn điệu trong $K$, độ lồi trong $K$, Và $V \geq \max(S-K, 0)$. Việc đo tỷ lệ vi phạm trên hộp tham số sẽ biến câu hỏi mở của chính bài viết này — chúng ta có thể đảm bảo các điều kiện không có chênh lệch giá trong toán tử đã học không? — từ việc vẫy tay thành một con số.

4. Bất biến rời rạc, được kiểm tra thay vì khẳng định. Đào tạo tại $N_S = 128$, đánh giá tại $N_S = 512$, báo lỗi. Chế độ lỗi dự kiến ​​được đặt tên và cụ thể: Gibbs reo vang ở chỗ thắt $\max(S-K, 0)$. Cơ sở Fourier bị cắt cụt đang xây dựng lại một hàm có đạo hàm bậc nhất không liên tục dao động xung quanh nó và độ phân giải siêu cao không bắn có thể làm cho điều đó trở nên tồi tệ hơn thay vì tốt hơn bằng cách hiển thị các chế độ mà độ phân giải huấn luyện chưa từng thấy. Nếu độ phân giải siêu giảm xuống gần cuộc đình công, thì kết quả tiêu cực đó sẽ có giá trị hơn tuyên bố tiếp thị mà nó thay thế - không ai trong tài liệu của FNO định giá các lựa chọn có đường cong hoàn trả.

Nếu không thể chạy thử nghiệm 1–4 thì bài viết này sẽ không được xuất bản. Những gì còn lại nếu không có chúng là một bản trình bày tốt về bài báo ICLR của người khác.

Ngoài các lựa chọn Vanilla

Giả sử chương trình nghị sự ở trên vẫn tồn tại khi tiếp xúc với phép đo, khuôn khổ FNO sẽ mở rộng một cách tự nhiên sang các công cụ phức tạp hơn:

• Quyền chọn kiểu Mỹ: Thêm ranh giới tập thể dục sớm làm kênh đầu ra bổ sung. FNO tìm hiểu đồng thời cả bề mặt giá và ranh giới thực hiện tối ưu.
• Tùy chọn rào cản: Mã hóa các mức rào cản làm kênh đầu vào. Lưu ý rằng rào cản là điểm gián đoạn thứ hai, và mối quan ngại của Gibbs trong chương trình đo lường được áp dụng mạnh mẽ hơn chứ không phải ít hơn.
• Rổ nhiều tài sản: Sử dụng FNO 2D hoặc 3D cho các tùy chọn giỏ trên 2–3 cơ sở. Lời nguyền về chiều ít nghiêm trọng hơn so với các bộ giải dựa trên lưới vì FNO hoạt động trên một số chế độ cố định.
• Biến động cục bộ: Nhập toàn bộ bề mặt biến động cục bộ Dupire $\sigma_{\text{loc}}(S,t)$ như một hàm không gian. Đây là trường hợp sử dụng tự nhiên nhất cho việc học toán tử — đầu vào là một hàm chứ không phải tham số vô hướng.

Kết luận

Sự đóng góp của Toán tử thần kinh Fourier mang tính khái niệm trước khi nó được tính toán: thay vì giải từng PDE một lần, bạn tham số hóa chính toán tử giải pháp đó và thực hiện điều đó trong không gian Fourier mang lại một kiến trúc $O(n \log n)$, phổ biến trên các toán tử liên tục và độ phân giải linh hoạt theo cấu trúc. Điều đó theo sau từ Li et al. (2021) và từ đoạn mã trên chạy.

Những gì không theo sau là một con số tăng tốc. Các số liệu 100x–1000x của tài liệu được đo lường dựa trên các điểm chuẩn linh hoạt so với các đường cơ sở mà chất lượng của chúng hiếm khi được công bố và loạt bài này đã dành cả một bài viết để chỉ ra bao nhiêu phần trong tiêu đề như vậy thường là thuật toán thay vì phần cứng. Những tuyên bố sẽ biện minh cho việc đưa người vận hành vào một công cụ định giá — độ chính xác fp32 ở mức phần trăm, tỷ lệ vi phạm không chênh lệch giá có giới hạn, độ phân giải siêu vượt qua vòng quay thanh toán và đường cong tăng tốc so với bộ giải CPU có thẩm quyền — đều có thể đo lường được, tất cả đều rẻ trên Black-Scholes vì ​​biểu mẫu đóng tồn tại và tất cả vẫn chưa được đo lường ở đây.

Đó là trạng thái của dự thảo này: cơ chế là có thật, lời hứa là hợp lý và bằng chứng đang chờ xử lý.

Tài liệu tham khảo và đọc thêm:

• Li, Z., Kovachki, N., Azizzadenesheli, K., và cộng sự. "Toán tử thần kinh Fourier cho phương trình vi phân từng phần tham số." ICLR 2021. arXiv:2010.08895
• Lu, L., Jin, P., Pang, G., Zhang, Z., & Karniadakis, G.E. "Tìm hiểu các toán tử phi tuyến thông qua DeepONet." Trí tuệ máy tự nhiên, 2021. doi:10.1038/s42256-021-00302-5
• Li, Z., và cộng sự. "Toán tử thần kinh thông tin vật lý để học các phương trình vi phân từng phần." Tạp chí khoa học dữ liệu ACM/IMS, 2024. OpenReview
• neuraloperator Thư viện PyTorch: github.com/neuraloperator/neuraloperator
• Salvador, M., và cộng sự. "Mạng lưới thần kinh học về phương trình Black-Scholes để định giá quyền chọn." arXiv:2405.05780
• Bài, Y., và cộng sự. "AI Black-Scholes: Mạng lưới thần kinh được thông tin về tài chính." arXiv:2412.12213