Нейронный оператор Фурье для финансового моделирования на основе PDE

Каждая нейронная сеть в этом блоге до сих пор аппроксимировала функцию: входное число, выходное число. Нейронный оператор Фурье аппроксимирует оператор — карту между бесконечномерными функциональными пространствами, где входными данными является вся поверхность волатильности, а выходными данными — вся поверхность цены. Это другой объект, для него требуется другое оборудование, и именно оно является целью этой статьи: обучаемое комплексное ядро, применяемое к самым низким модам Фурье, оцениваемое посредством двустороннего преобразования БПФ в $O(n \log n)$.

Ценообразование опционов — вот где это касается финансов. Блэк-Шоулз, Хестон, локальная волатильность — все PDE, все они решены сегодня по одному набору параметров за раз. Оператор изучает все семейство параметров одновременно, и в результате прямой проход представляет собой одно пакетное ядро ​​графического процессора, а не цикл с временным регулированием.

Это обещание. Честная версия этой статьи отделяет механику, которая надежна и воспроизводима из приведенного ниже кода, от заявлений о производительности, которые в литературе 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 (Лу и др., 2021): использует сеть филиалов для кодирования функции ввода и магистральную сеть для кодирования местоположения запроса. Результатом является их внутренний продукт. Основано на теореме об универсальной аппроксимации операторов Чена и Чена (1995).

2. Нейронный оператор Фурье (Ли и др., 2021): параметризует интегральное ядро ​​в пространстве Фурье, используя БПФ для эффективной глобальной свертки. Резолюция инвариантна по построению.

Оба являются универсальными аппроксиматорами для непрерывных операторов, но FNO имеет структурное преимущество для задач УЧП: его спектральное смещение естественным образом отражает гладкую глобальную структуру решений УЧП. У него также есть структурный недостаток конкретно для выплат по опционам, к которому мы еще вернемся: усеченный базис Фурье и излом при страйке не являются естественными союзниками.

Архитектура FNO в деталях

Нейронный оператор Фурье, представленный Ли и др. на ICLR 2021, основан на простом, но важном наблюдении: функция Грина (интегральное ядро) многих УЧП имеет компактное представление в пространстве Фурье. Вместо изучения ядра в физическом пространстве, что требует $O(n^2)$ параметры для $n$ точки сетки — FNO изучает это в частотном пространстве только с самыми низкими $k_{\max}$ режимы, снижая сложность до $O(n \log n)$ через БПФ.

Итеративная архитектура

ФНО состоит из:

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$ — локальное линейное преобразование (поточечное $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).

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 считается инвариантным к дискретизации: после обучения на сетке размером $n$, его можно оценить на любом разрешении $m \neq n$ просто регулируя размер БПФ и дополняя нулями или усекая спектральные веса. Это свойство суперразрешения с нулевым выстрелом уникально среди нейронных решателей PDE — и это первое утверждение в этой статье, которое заслуживает измерения, а не цитирования. См. программу измерений ниже.

PDE, для которого мы изучаем оператор

PDE Блэка-Шоулза — полученное, разобранное по терминам и представленное в закрытой форме решением «колл/пут» в Формуле Блэка-Шоулза — является целью оператора:

$\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 в литературе.

Формулировка ФНО

Мы переформулируем проблему как обучение операторов. Определить:

• Функция ввода $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)

    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.

Увеличение масштаба: модель стохастической волатильности Хестона

Постоянная волатильность — это заведомо ложное предположение, и почему оно терпит неудачу (улыбка, толстые хвосты) — это тема раздела «Суровая реальность» Формулы Блэка-Шоулза. Хестон исправляет это, делая дисперсию второй переменной состояния:

$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)$ снова оплачивает полную стоимость. Оператор платит его один раз во время обучения. Двумерная пространственная структура УЧП Хестона также отображается непосредственно на двумерное БПФ в слоях Фурье, поэтому приведенная ниже архитектура обобщается с изменением размеров, а не с перепроектированием.

FNO для ценообразования опционов: реализация PyTorch

Ниже представлена полная автономная реализация FNO для изучения оператора Блэка-Шоулза. Архитектура соответствует Li et al. (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:
        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: практическое сравнение

Нейронные сети, основанные на физике, и нейронные операторы Фурье представляют собой фундаментально разные подходы к решению УЧП с помощью нейронных сетей. Понимание их компромиссов является практической причиной вообще заботиться об обучении операторов.

PINN: оптимизация для каждого экземпляра

PINN помещают остаток PDE непосредственно в потерю — Проблема Навье-Стокса описывает механизм, автодифференциацию physics_loss реализация и результат поиска сингулярности DeepMind. Единственное свойство, которое здесь имеет значение, является структурным: ** PINN обучается для каждого набора параметров. ** Изменение $\sigma$, $r$, $K$ или $T$ и вы снова оптимизируете с нуля.

Сильные стороны: Маркированные данные не требуются. Непосредственно обеспечивает структуру PDE. Работает для любого PDE, который вы можете записать.

Слабые стороны: необходимо переобучать для каждого нового набора параметров. $(\sigma, r, K, T)$. Обучение включает в себя балансировку нескольких условий потерь (остаток PDE, граничные условия, начальные условия), что часто приводит к патологиям оптимизации. Сходимость может быть медленной — обычно 10 000–100 000 шагов градиента на один экземпляр проблемы. Не работает в многомасштабных и хаотичных системах, где картина потерь становится крайне невыпуклой.

FNO: амортизированное обучение операторов

FNO узнает оператора решения на основе данных. Для этого требуется набор обучающих данных, созданный классическим решателем, но после обучения он обобщает все пространство параметров.

Сильные стороны: результаты опубликованных тестов достигают субмиллисекундных значений. Обобщает невидимые параметры без повторного обучения. Инвариантность к разрешению — обучение с низким разрешением, оценка с высоким разрешением. Естественно обрабатывает гладкие решения 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: глубокое обучение по книгам лимитных ордеров, и она применяется без изменений. Далее следует только то, что специфично для оператора.

Конвейер данных: выборка пространства параметров

Генерация обучающих данных является основным узким местом, и в отличие от модели рыночных данных вы выбираете свое собственное распределение, а это означает, что вы можете ошибиться, и потери будут незаметны. Для оператора Блэка-Шоулза с 4 параметрами достаточно 5 000–10 000 отсчетов. Для Хестона с 5 параметрами плюс двумерная пространственная область типично 20 000–50 000 образцов. Используйте адаптивную выборку: концентрируйте выборки в регионах параметров, где решение быстро меняется — близкое к деньгам, короткие сроки погашения, высокая волатильность — потому что единая выборка блока тратит большую часть своего бюджета на регионы глубокого ITM и глубокого OTM, где оператор почти линейен и хорошо учится на очень небольшом количестве примеров.

Настройка архитектуры

• Режимы ($k_{\max}$): Начните с $N/4$ где $N$ — размер пространственной сетки. Для $N=256$, используйте режимы 32–64. Слишком мало режимов теряют детализацию вблизи границ простирания; слишком многие из них соответствуют шуму.
• Слои: стандартно 4 слоя Фурье. Более глубокие сети (6–8) помогают решать 2D-задачи, такие как Хестон, но увеличивают память.
• Скрытые каналы: 64 для 1D Блэка-Шоулза, 128 для 2D Хестона. Масштабируйте со сложностью проблемы.

Точность: вопрос fp32

SpectralConv1d распределяет torch.cfloat — комплекс с одинарной точностью — и каждый цикл БПФ выполняется с этой точностью. В этом блоге уже наблюдался, как финансовый конвейер fp32 возвращает тихий мусор в The GPU Precision Trap, где математически правильная формула суммы префиксов катастрофически терялась при значениях fp32. Аналогичный вопрос здесь стоит прямо: при $S \approx 100$ с ценами, указанными до цента, сохраняется ли спектральный обход fp32 туда и обратно $10^{-2}$ абсолютный, или рост промежуточной величины БПФ съедает последние значащие цифры?

Контроль ошибок

Для ценообразования производственных вариантов вам нужны границы ошибок, которые вы можете защитить.

1. Калиброванная неопределенность: стандартное отклонение ансамбля не является гарантией покрытия, и в этом блоге есть механизм, позволяющий сделать это правильно — разбить конформное по заданной сетке параметров, с ACI/DtACI для необменного случая, в Конформное предсказание для определения размера позиции с учетом риска. Обертывание FNO в расщепленную конформную структуру $(\sigma, r, K, T)$ сетка дает интервалы цены без распределения.
2. Мониторинг остатков: вычислите остаток PDE прогноза FNO в качестве последующей проверки. Если $\|\text{residual}\| > \epsilon$, вернитесь к классическому решателю. Это бесплатно при выводе — остаток представляет собой трафарет конечной разности в уже имеющемся у вас массиве.
3. Активное обучение. Направляйте входные данные с высокой неопределенностью в классический решатель, добавляйте результаты в обучающий набор и периодически переобучайте. Ширина конформного интервала из (1) является естественным сигналом маршрутизации.

Программа измерений

Это та часть, которая решает, стоит ли развертывать описанную выше архитектуру, но ничего из этого еще не сделано. Он указан здесь, а не похоронен, потому что альтернатива — утверждение об ускорении заголовка — это именно тот регистр, которого хочет избежать этот блог.

1. Ускорение — это кривая, а не число. Когда графический процессор окупается устанавливает форму: $S(B) = aB/(O + bB)$, поднимаясь из-под накладных расходов в $B=1$ до плато, связанного с вычислениями, и он показывает, что заголовок 167x разлагается на 27x алгоритма, умноженного на 6,2x аппаратного обеспечения. Измерение FNO должно следовать этому шаблону: $B \in \{1, 8, 64, 512\}$ и сообщите всю кривую. Крайне важно, что базовая линия должна представлять собой векторизованный, многоядерный решатель конечных разностей — black_scholes_fd выше — это интерпретированный двойной цикл, точная базовая линия «худшей реализации ЦП», названная в статье, и сравнение с ней пакетного оператора графического процессора даст число, которое ничего не значит.

2. Точность относительно закрытой формы. Это эксперимент, который Блэк-Шоулз проводит почти бесплатно, и который тесты гидродинамики вообще не могут выполнить: тренируйтесь на данных, сгенерированных FD, а затем сравнивайте их с точными данными. 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)$. Усеченный базис Фурье, восстанавливающий функцию с прерывистой первой производной, колеблется вокруг нее, а сверхразрешение с нулевым выстрелом может сделать это скорее хуже, чем лучше, раскрывая режимы, которые никогда не видело обучающее разрешение. Если сверхразрешение ухудшается вблизи удара, этот отрицательный результат более ценен, чем маркетинговое заявление, которое он заменяет — никто в литературе FNO не оценивает варианты с изломом выигрыша.

Если эксперименты 1–4 невозможно провести, эту статью не следует отправлять. Без них остается только хорошо написанное изложение чужой статьи ICLR.

За пределами ванильных опций

Если предположить, что вышеуказанная программа выдержит контакт с измерениями, структура FNO естественным образом распространяется на более сложные инструменты:

• Американские опционы: добавьте границу раннего исполнения в качестве дополнительного выходного канала. FNO одновременно изучает как поверхность цены, так и оптимальную границу исполнения.
• Параметры барьера: кодируйте уровни барьера как входные каналы. Обратите внимание, что барьер — это второй разрыв, и проблема Гиббса в программе измерений применима с большей, а не меньшей силой.
• Корзины с несколькими активами: используйте 2D или 3D FNO для опционов на корзину на 2–3 базовых актива. Проклятие размерности менее серьезное, чем для решателей на основе сетки, поскольку FNO работает с фиксированным количеством режимов.
• Локальная волатильность: введите полную поверхность локальной волатильности Дюпире. $\sigma_{\text{loc}}(S,t)$ как пространственная функция. Это наиболее естественный вариант использования для обучения операторов — входные данные является функцией, а не скалярным параметром.

Заключение

Вклад нейронного оператора Фурье носит концептуальный характер, прежде чем он становится вычислительным: вместо решения одного УЧП за раз вы параметризуете сам оператор решения, и выполнение этого в пространстве Фурье дает архитектуру, которая $O(n \log n)$, универсальный для непрерывных операторов и гибкий по разрешению по конструкции. Это следует из Li et al. (2021) и из приведенного выше кода, который выполняется.

Чего не следует, так это числа ускорения. Цифры 100–1000x, приведенные в литературе, измеряются на основе гибких тестов по сравнению с базовыми показателями, качество которых редко указывается, и в этой серии целая статья посвящена тому, чтобы показать, какая часть такого заголовка обычно является алгоритмом, а не аппаратным обеспечением. Заявления, которые могли бы оправдать включение оператора в механизм ценообразования — точность fp32 на уровне цента, ограниченный уровень безарбитражных нарушений, суперразрешение, выдерживающее изгиб выигрыша, и кривая ускорения по сравнению с компетентным решателем ЦП — все измеримы, все дешево по Блэку-Шоулзу, потому что закрытая форма существует, и все еще не измерены здесь.

Таково состояние этого проекта: механизм реален, обещания правдоподобны, а доказательства ожидаются.

Ссылки и дополнительная литература:

• Ли З., Ковачки Н., Азиззаденешели К. и др. «Нейронный оператор Фурье для параметрических уравнений в частных производных». ICLR 2021. arXiv:2010.08895
• Лу Л., Джин П., Панг Г., Чжан З. и Карниадакис Г.Е. «Изучение нелинейных операторов через DeepONet». Природный машинный интеллект, 2021. doi:10.1038/s42256-021-00302-5
• Ли З. и др. «Нейронный оператор с учетом физики для изучения уравнений в частных производных». Журнал ACM/IMS Data Science, 2024 г. OpenReview
• neuraloperator Библиотека PyTorch: github.com/neuraloperator/neuraloperator
• Сальвадор М. и др. «Нейронное изучение уравнения Блэка-Шоулза для ценообразования опционов». arXiv:2405.05780
• Бай Ю. и др. «ИИ Блэка-Шоулза: нейронная сеть, информированная о финансах». arXiv:2412.12213