Physics-Informed Neural Networks for Options Pricing

PINN'larni derivativlarga qo'llashdagi qiziq jihat Black-Scholes emas. Black-Scholes yopiq shaklga ega; uni takrorlaydigan tarmoq natija emas, balki sanity check. Qiziq jihat — yopiq shaklga ega bo'lmagan va chekli ayirmalar imkoniyati tugaydigan holatlar: aralash xususiy hosilali $\partial^2 V / \partial S \partial v$ ga ega Heston ikki faktorli PDE'si, Amerika opsionlarining erkin chegara masalasi va Mertonning integral hadi sohadagi har bir nuqtani boshqa barcha nuqtalar bilan bog'laydigan qisman integro-differensial tenglamasi.

Ushbu postda bularning har biri loss funksiyasiga qanday kiritilishini ko'rsatamiz. Aniqrog'i: Black-Scholes PINN'ini o'qitiladigan qiladigan log-narx residuali, aralash hosilasi autograd orqali bepul olinadigan uch kirishli Heston tarmog'i, muddatidan oldin bajarishni penalty va ikki tarmoq orqali ko'rib chiqish hamda sakrash integralini PDE residuali ichiga kiritadigan Gauss-Hermite kvadraturasi.

Bu benchmark emas. Quyida natijaga o'xshab ko'rinadigan har bir raqam yo maqsad, yo manba bo'lib, shunday belgilangan. O'lchash bosqichi oxirida berilgan.

PINN'lar Raissi va boshqalar (2019) tomonidan joriy etilgan; mexanika ushbu blogdagi Navier-Stokes masalasi maqolasida allaqachon yoritilgan. U yerda xuddi shu autograd-residual usuli suyuqlik tenglamalaridagi singulyarliklarni qidiradi: PDE loss hadi bo'ladi, autodiff tarmoqning kirishlarga nisbatan aniq hosilalarini beradi va hech qanday grid qurilmaydi. Bu yerda o'zgaradigan yagona narsa loss ichiga qaysi PDE kiritilishidir.

Black-Scholes PDE'si fizikaviy cheklov sifatida

Black-Scholes PDE'si, uning terminal to'lovi $\max(S-K,0)$ va uning ortidagi arbitrajsiz argument Black-Scholes formulasi maqolasida yoritilgan — bu bo'lim ularni faraz qiladi va to'g'ridan-to'g'ri tarmoq o'qitiladigan shaklga o'tadi.

Log-narx transformatsiyasi

To'g'ridan-to'g'ri $S$ bilan ishlash muammoli: soha $[0, \infty)$, PDE esa o'zgaruvchan koeffitsientlarga ega. Standart $x = \ln(S)$ transformatsiyasi uni doimiy koeffitsientli shaklga o'tkazadi:

$\frac{\partial V}{\partial t} + \frac{1}{2}\sigma^2 \frac{\partial^2 V}{\partial x^2} + \left(r - \frac{1}{2}\sigma^2\right)\frac{\partial V}{\partial x} - rV = 0$

Bu $x \in (-\infty, \infty)$ dagi konveksiya-diffuziya-reaksiya tenglamasidir. $S^2$ va $S$ o'zgaruvchan koeffitsientlari yo'qoladi, bu tarmoq uchun muhim: kattaligi $S^2$ bilan masshtablanuvchi residual sohaning uzoq chekkasida hukmron bo'ladi va optimizer resursini o'sha yerga sarflaydi.

Black-Scholes uchun PINN loss'i

Tarmoqni $u_\theta(x, t)$ deb olaylik. Ichki sohada $N_r$ kollokatsiya nuqtasi, chegaralarda $N_b$ ta va terminal vaqtda $N_0$ ta nuqta tanlaymiz:

$\mathcal{L}_{\text{PDE}} = \frac{1}{N_r}\sum_{i=1}^{N_r}\left[\frac{\partial u_\theta}{\partial t} + \frac{1}{2}\sigma^2 \frac{\partial^2 u_\theta}{\partial x^2} + \left(r - \frac{\sigma^2}{2}\right)\frac{\partial u_\theta}{\partial x} - r u_\theta\right]^2$

$\mathcal{L}_{\text{IC}} = \frac{1}{N_0}\sum_{j=1}^{N_0}\left[u_\theta(x_j, T) - \max(e^{x_j} - K, 0)\right]^2$

$\mathcal{L}_{\text{BC}} = \frac{1}{N_b}\sum_{k=1}^{N_b}\left[u_\theta(x_{\min}, t_k)\right]^2 + \frac{1}{N_b}\sum_{k=1}^{N_b}\left[u_\theta(x_{\max}, t_k) - (e^{x_{\max}} - Ke^{-r(T-t_k)})\right]^2$

Har bir xususiy hosila torch.autograd.grad orqali create_graph=True bilan hisoblanadi, shuning uchun backpropagation davomida gradientlar hosila hisoblash orqali ham o'tadi. Shu bitta flag butun implementatsiya hiylasidir.

PyTorch implementatsiyasi

Quyidagi parametrlar darslikdagidan ko'ra kriptoga mos: equity desk'dagi $\sigma = 0.2$, $T = 1.0$ o'rniga $\sigma = 0.7$ va $T = 0.08$ (taxminan 30 kunlik BTC opsioni). Qisqa muddat va yuqori volatillik to'lov kink'i eng keskin va PINN'ni o'qitish eng qiyin bo'lgan rejimdir — maqsad ham shu.

import torch
import torch.nn as nn
import numpy as np

r = 0.05        # risk-free rate
sigma = 0.7     # volatility
K = 1.0         # strike (moneyness-normalized)
T = 0.08        # ~30 days
x_min, x_max = -1.0, 1.0  # log-price domain (S/K in [0.37, 2.72])

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


class BSPINN(nn.Module):
    """Physics-Informed Neural Network for Black-Scholes PDE."""

    def __init__(self, hidden_dim=128, num_layers=4):
        super().__init__()
        layers = [nn.Linear(2, hidden_dim), nn.Tanh()]
        for _ in range(num_layers - 1):
            layers += [nn.Linear(hidden_dim, hidden_dim), nn.Tanh()]
        layers.append(nn.Linear(hidden_dim, 1))
        self.net = nn.Sequential(*layers)

    def forward(self, x, t):
        inputs = torch.cat([x, t], dim=1)
        return self.net(inputs)


def compute_pde_residual(model, x, t):
    """Compute Black-Scholes PDE residual using autodiff."""
    x.requires_grad_(True)
    t.requires_grad_(True)
    u = model(x, t)

    grads = torch.autograd.grad(u, [x, t], grad_outputs=torch.ones_like(u),
                                create_graph=True)
    u_x, u_t = grads[0], grads[1]

    u_xx = torch.autograd.grad(u_x, x, grad_outputs=torch.ones_like(u_x),
                               create_graph=True)[0]

    residual = u_t + 0.5 * sigma**2 * u_xx + (r - 0.5 * sigma**2) * u_x - r * u
    return residual


def terminal_condition(x):
    """European call payoff: max(S - K, 0) = max(exp(x) - K, 0)."""
    return torch.relu(torch.exp(x) - K)


def train_pinn(epochs=10000, lr=1e-3, n_interior=5000, n_boundary=500, n_terminal=1000):
    model = BSPINN().to(device)
    optimizer = torch.optim.Adam(model.parameters(), lr=lr)
    scheduler = torch.optim.lr_scheduler.CosineAnnealingLR(optimizer, T_max=epochs)

    for epoch in range(epochs):
        optimizer.zero_grad()

        x_int = (torch.rand(n_interior, 1, device=device)
                 * (x_max - x_min) + x_min)
        t_int = torch.rand(n_interior, 1, device=device) * T

        residual = compute_pde_residual(model, x_int, t_int)
        loss_pde = (residual ** 2).mean()

        x_tc = (torch.rand(n_terminal, 1, device=device)
                * (x_max - x_min) + x_min)
        t_tc = torch.ones(n_terminal, 1, device=device) * T
        u_tc = model(x_tc, t_tc)
        loss_ic = ((u_tc - terminal_condition(x_tc)) ** 2).mean()

        t_bc = torch.rand(n_boundary, 1, device=device) * T

        x_lo = torch.full((n_boundary, 1), x_min, device=device)
        loss_bc_lo = (model(x_lo, t_bc) ** 2).mean()

        x_hi = torch.full((n_boundary, 1), x_max, device=device)
        target_hi = torch.exp(x_hi) - K * torch.exp(-r * (T - t_bc))
        loss_bc_hi = ((model(x_hi, t_bc) - target_hi) ** 2).mean()

        loss = loss_pde + 10.0 * loss_ic + loss_bc_lo + loss_bc_hi

        loss.backward()
        optimizer.step()
        scheduler.step()

        if epoch % 1000 == 0:
            print(f"Epoch {epoch:5d} | PDE: {loss_pde:.2e} | "
                  f"IC: {loss_ic:.2e} | BC: {loss_bc_lo + loss_bc_hi:.2e}")

    return model

Ikki strukturaviy tanlovni alohida qayd etish kerak:

• Terminal shartdagi og'irlik. To'lov masalani belgilagani uchun unga 10 baravar og'irlik beriladi. Kuchli majburlashsiz tarmoq PDE'ni hamma joyda nol chiqarib trivial qanoatlantirishi mumkin — bir jinsli PDE cheksiz ko'p yechimga ega, terminal shart esa bittasini tanlaydi.
• Kollokatsiya nuqtalarini har epoch'da qayta tanlash. Har qadamda yangi nuqtalar olinadi; bu residual uchun stoxastik regularizatsiya vazifasini bajaradi. Muqobil — o'zgarmas nuqtalar to'plami — tarmoqqa aynan shu koordinatalardagi residualga overfit qilish imkonini beradi.

Heston stoxastik volatillik modeliga kengaytirish

Black-Scholes yagona doimiy $\sigma$ bilan narxlaydi; bu aynan GARCH(1,1) volatillik prognozi rad etadigan farazdir. Heston volatillikni ikkinchi stoxastik faktor — oniy variance $v$ — sifatida kiritadi:

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

bu yerda $\kappa$ mean-reversion tezligi, $\theta$ uzoq muddatli variance, $\xi$ vol-of-vol va $dW_1 \cdot dW_2 = \rho\,dt$.

Narxlash PDE'si holatlar bo'yicha ikki o'lchamli:

$\frac{\partial V}{\partial t} + \frac{1}{2}vS^2\frac{\partial^2 V}{\partial S^2} + \rho\xi v S\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$

Meshsiz usul aynan shu yerda jozibador ko'rina boshlaydi. Chekli ayirmalar sxemasi $(S, v, t)$ bo'yicha grid talab qiladi — odatiy $200 \times 100 \times 500$ $10^7$ ta tugun demakdir. Stoxastik stavkalar kabi uchinchi faktor qo'shilsa, grid amaliy bo'lmay qoladi. Monte Carlo o'lchamga yaxshiroq masshtablanadi, lekin ayniqsa Greek'lar uchun sekin konvergensiya qiladi.

Heston uchun PINN arxitekturasi

Tarmoq $x = \ln S$ bilan uchta $(x, v, t)$ kirish oladi. ADI sxemalarini noqulay qiladigan aralash xususiy hosila $\partial^2 u / \partial x \partial v$ yana bitta autograd.grad chaqiruvi bilan olinadi:

class HestonPINN(nn.Module):
    def __init__(self, hidden_dim=256, num_layers=5):
        super().__init__()
        layers = [nn.Linear(3, hidden_dim), nn.Tanh()]
        for _ in range(num_layers - 1):
            layers += [nn.Linear(hidden_dim, hidden_dim), nn.Tanh()]
        layers.append(nn.Linear(hidden_dim, 1))
        self.net = nn.Sequential(*layers)

    def forward(self, x, v, t):
        return self.net(torch.cat([x, v, t], dim=1))


def heston_pde_residual(model, x, v, t, kappa, theta, xi, rho, r):
    x.requires_grad_(True)
    v.requires_grad_(True)
    t.requires_grad_(True)
    u = model(x, v, t)

    u_x, u_v, u_t = torch.autograd.grad(
        u, [x, v, t], torch.ones_like(u), create_graph=True
    )
    u_xx = torch.autograd.grad(u_x, x, torch.ones_like(u_x), create_graph=True)[0]
    u_vv = torch.autograd.grad(u_v, v, torch.ones_like(u_v), create_graph=True)[0]
    u_xv = torch.autograd.grad(u_x, v, torch.ones_like(u_x), create_graph=True)[0]

    residual = (
        u_t
        + 0.5 * v * u_xx
        + rho * xi * v * u_xv
        + 0.5 * xi**2 * v * u_vv
        + (r - 0.5 * v) * u_x
        + kappa * (theta - v) * u_v
        - r * u
    )
    return residual

u_xv $u_x$ ni $v$ bo'yicha differensiallash orqali olinadi va birinchi chaqiruv yaratgan graph qayta ishlatiladi. Aralash hosilaning simmetriyasi $u_v$ ni $x$ bo'yicha differensiallash ham xuddi shu tensorni berishi kerakligini anglatadi; float32'da ular aynan teng bo'lmaydi, bu esa graph qanday ishlayotganini tekshirish uchun arzon diagnostikadir.

Amerika opsionlari va erkin chegara masalalari

Amerika opsionlari muddatidan oldin bajarish cheklovini qo'shadi: qiymat hech qachon ichki qiymatdan past bo'lmasligi kerak. Bu PDE'ni erkin chegara masalasiga, ekvivalent ravishda chiziqli komplementarlik masalasiga (LCP) aylantiradi:

$\frac{\partial V}{\partial t} + \mathcal{L}V \leq 0, \quad V \geq \Phi(S), \quad \left(\frac{\partial V}{\partial t} + \mathcal{L}V\right)(V - \Phi(S)) = 0$

bu yerda $\mathcal{L}$ Black-Scholes operatori, $\Phi(S)$ esa to'lovdir. Buni loss'ga kiritishning ikki usuli bor.

Penalty usuli

Komplementarlik cheklovini silliq penalty bilan almashtiring:

$\frac{\partial V}{\partial t} + \mathcal{L}V + \rho_p \cdot \max(\Phi(S) - V, 0) = 0$

$\rho_p$ katta bo'lsin (odatda $10^4$ dan $10^6$ gacha). $V$ ichki qiymatdan pastga tushganda penalty uni yuqoriga majburlaydi va PINN loss'i quyidagicha bo'ladi:

$\mathcal{L}_{\text{PDE}}^{\text{American}} = \frac{1}{N_r}\sum_i \left[\frac{\partial u_\theta}{\partial t} + \mathcal{L}u_\theta + \rho_p \cdot \max(\Phi - u_\theta, 0)\right]^2$

Arxitektura o'zgarmaydi, faqat residual o'zgaradi. Xarajat — yomon conditioning tradeoff'iga ega yangi hyperparameter: juda kichik bo'lsa cheklov buziladi, juda katta bo'lsa loss landshafti penalty hadi hukmronligida qoladi.

To'g'ridan-to'g'ri erkin chegara yondashuvi

Ikki tarmoqni birgalikda o'qiting: biri narx $u_\theta(S, t)$ uchun, ikkinchisi optimal bajarish chegarasi $S^*_\phi(t)$ uchun. Loss continuation sohasidagi PDE, chegaradagi smooth-pasting sharti va bajarish sohasidagi to'lovni o'z ichiga oladi. Chegara birinchi darajali output sifatida olinadi — Amerika book'ini hedgelash uchun aslida sizga kerak bo'lgani ham shu.

PINN'lar bilan jump-diffusion modellar

Merton modeli geometrik Brown harakatiga Puasson sakrashlarini qo'shadi:

$dS = (r - \lambda \bar{k})S\,dt + \sigma S\,dW + S\,dJ$

bu yerda $J$ intensivligi $\lambda$ va log-normal sakrash o'lchamlariga ega compound Poisson jarayonidir. Narxlash qisman integro-differensial tenglamaga (PIDE) aylanadi:

$\frac{\partial V}{\partial t} + \frac{1}{2}\sigma^2 S^2 \frac{\partial^2 V}{\partial S^2} + (r - \lambda\bar{k})S\frac{\partial V}{\partial S} - (r + \lambda)V + \lambda \int_0^\infty V(Sy, t) f(y)\,dy = 0$

bu yerda $f(y)$ sakrash ko'paytiruvchisining zichligidir.

Integral chekli ayirmalarni ishdan chiqaradi — u sohadagi har bir nuqtani qolgan barcha nuqtalar bilan bog'lab, solver tayanadigan bandli strukturani yo'q qiladi. PINN yo'qotadigan bunday strukturaga ega emas. Integral residualdagi navbatdagi had bo'lib, har bir kollokatsiya nuqtasida kvadratura orqali hisoblanadi; tarmoq hamma joyda aniqlangani uchun $V(Sy, t)$ interpolyatsiya emas, bepul forward pass'dir:

def jump_integral(model, x, t, lam, mu_j, sigma_j, n_quad=32):
    """Approximate jump integral using Gauss-Hermite quadrature."""
    nodes, weights = np.polynomial.hermite.hermgauss(n_quad)
    nodes = torch.tensor(nodes, dtype=torch.float32, device=x.device)
    weights = torch.tensor(weights, dtype=torch.float32, device=x.device)

    y_nodes = mu_j + sigma_j * np.sqrt(2) * nodes
    integral = torch.zeros_like(x)

    for i in range(n_quad):
        x_shifted = x + y_nodes[i]
        v_shifted = model(x_shifted, t)
        integral += weights[i] * v_shifted

    integral *= 1.0 / np.sqrt(np.pi)
    return integral

Shunday qilib PIDE residuali:

$\text{Residual} = \frac{\partial u}{\partial t} + \frac{1}{2}\sigma^2 u_{xx} + (r - \lambda\bar{k} - \frac{\sigma^2}{2})u_x - (r + \lambda)u + \lambda \cdot I[u]$

bu yerda $I[u]$ kvadratura yaqinlashuvidir. Sikl har bir o'qitish qadamida n_quad ta qo'shimcha forward pass talab qiladi va ularning barchasi autograd graph'iga tushadi — sakrashlarning haqiqiy narxi matematika emas, xotiradir.

An'anaviy usullar bilan taqqoslash

Strukturaviy farqlar haqiqiy bo'lib, benchmark'siz ham bayon qilinishi mumkin:

Odatda bu yerda bo'ladigan performance qatorlari — o'qitish vaqti, inference latency, aniqlik — ataylab kiritilmadi, chunki ularni o'lchash ochiq ish, jadvalga kiritiladigan natija emas.

PINN'lar qayerda ehtimol yutadi

Real-time qayta narxlash. O'qitilgach, baholash batch bo'yicha forward pass bo'ladi; shuning uchun butun book har bir parametr to'plami uchun alohida solve o'rniga bitta kernel launch'da qayta narxlanadi. Bu real book o'lchamlarida yaxshi sozlangan Crank-Nicolson solver'idan ustun keladimi — empirik savol va bu yerda o'lchanmagan.

Yuqori o'lchamli modellar. Stoxastik volatillik, stoxastik stavkalar va sakrashlar 4+ o'lchamdir; bu yerda chekli ayirmalar amalda ishlamaydi. PINN'lar o'lcham oshganda muloyimroq yomonlashadi, ammo o'qitish qiyinligi saqlanadi.

Uzluksiz Greek'lar. Tarmoq silliq va differensiallanuvchi, shuning uchun Delta, Gamma, Theta va Vega narxning PDE residuali bilan bir xil autograd mexanizmidan keladi — bump-and-revalue ham, chekli ayirma shovqini ham yo'q. Bu postdagi eng kuchli da'vo va orqasida o'lchangan Gamma sirti eng ko'p kerak bo'lgan da'vo ham shu.

Parametrik yechimlar. Model parametrlarini ($\sigma$, $\kappa$, $\theta$) tarmoq kirishlari sifatida berish bitta PINN'ga yagona kalibratsiya o'rniga modellar oilasini qamrab olish imkonini beradi.

PINN'lar qayerda qiynaladi

O'qitish narxi. Bitta parametr to'plamidagi bitta opsion uchun chekli ayirmali solve PINN birinchi ming epoch'ini tugatmasidan oldin yakunlanadi.

Xato chegaralari yo'q. Richardson ekstrapolyatsiyali chekli ayirmalar ma'lum konvergensiya tartibi bilan mashina aniqligiga yetadi. PINN loss qiymatini beradi, bu esa xato chegarasi emas. Noaniqlikni hisobga oluvchi variantlar (Bai va boshqalar, 2025) confidence interval qo'shadi, biroq soha hali yosh.

Optimallashtirish qiyinligi. Loss landshafti yomon no-konveks; PDE, chegara va terminal hadlar orasidagi og'irlikni tanlash tuning masalasidir. Xarakterli failure — tarmoq PDE residualini deyarli nolga tushiradi, ammo chegaraviy shartlarni butunlay e'tiborsiz qoldiradi: noto'g'ri masalaning mutlaqo to'g'ri yechimi.

Reproduktivlik. Turli seed'lar, kollokatsiya taqsimotlari va optimizer sozlamalari mazmunan turli yechimlarga olib kelishi mumkin. Ensembling yordam beradi, ammo xarajatni ko'paytiradi.

Oxirgi ikki jihatni grafikaga aylantirish ayniqsa foydali, chunki bu postni qayta implement qiladigan har kim ularga duch keladi.

Hali nimani o'lchash kerak

Ushbu maqolaning halol holati: formulalar to'g'ri va kod ishlaydi, ammo bu yerda hech narsa ushbu desk hardware'ida yoki ma'lumotlarida benchmark qilinmagan. Uni derivatsiyadan natijaga aylantiradigan bosqich:

1. Yopiq shakldagi Black-Scholes bilan sup-norm va RMSE $(S, t)$ grid bo'ylab, har bir seed uchun, beshta seed. Odatdagi folklore maqsad — 4+ o'nlik kasrgacha moslik; maqsad $\sigma = 0.7$, $T = 0.08$ da buni sinash va qayerda ishlamasligini ko'rsatadigan seed'larni chop etish.
2. Faqat narx xatosi emas, Delta va Gamma xatosi. To'rt raqamgacha narxga mos, lekin shovqinli $\Gamma$'ga ega tarmoq hedging uchun befoyda; shuning uchun Gamma qabul mezonidir.
3. Wall-clock o'qitish vaqti va 10 000 opsionli book uchun har bir opsion inference latency'si, aynan shu muammoni xuddi shu GPU'da yechuvchi Crank-Nicolson bilan taqqoslangan holda.
4. Failure mode'larni ataylab takrorlash. Tarmoq PDE'ni qanoatlantirib, chegarani o'tkazib yuborguncha boundary loss og'irligini kamaytiring; beshta seed ishga tushirib farqni chizing. Ikkalasi ham arzon va yana bir to'g'ri ko'rinadigan narx sirtidan foydaliroq.
5. Haqiqiy Deribit BTC quote'lariga moslash yoki hech bo'lmaganda yuqoridagi kriptoga mos parametrlarni $\sigma = 0.2$, $T = 1.0$ ga qaytarmang.
6. Arxitektura va optimizer tanlovlarini maslahat emas, natija sifatida berish. Kengroq-chuqurroq, tanh va ReLU (ReLU'ning uzlukli ikkinchi hosilasi residualni sezilarli buzishi kerak), $\lambda_{\text{IC}}$ sweep'lari va Adam-then-L-BFGS bilan faqat Adam'ni taqqoslash — barchasi bir qatorli tajribalar. Ular bajarilmaguncha bu adabiyotdan takrorlangan folklore, ushbu post esa ularni tavsiya sifatida takrorlamaydi.

O'lchashsiz ham saqlanadigan ikki strukturaviy da'vo bor, chunki ular ishga tushirishga emas, formulaga xos: log-narx koordinatalaridan foydalanish (PDE doimiy koeffitsientli bo'ladi, bu algebra haqidagi fakt) va terminal shartga PDE hadidan yuqori og'irlik berish (bir jinsli PDE nol yechimga ega, bu masalaning fakti).

Yana nimalar mavjud

Bilishga arziydigan yo'nalishlar, ularning hech biri bu yerda sinovdan o'tmagan:

• Residual-adaptive kollokatsiya tanlovi — nuqtalarni bir tekis emas, residual katta joylarga, Black-Scholes uchun strike yaqiniga yoki Heston uchun Feller chegarasi yaqiniga joylashtiring. Implementatsiya qisqa:

def adaptive_resample(model, x_pool, t_pool, n_select):
    """Select collocation points with highest PDE residual."""
    with torch.no_grad():
        residuals = compute_pde_residual(model, x_pool, t_pool).abs()
    probs = residuals.squeeze() / residuals.sum()
    indices = torch.multinomial(probs, n_select, replacement=False)
    return x_pool[indices], t_pool[indices]

• Strike va maturity bo'yicha transfer learning — option chain'ni qoplaydigan kutubxonani saqlash uchun noldan o'qitish o'rniga qo'shni $(K, T)$ dan fine-tune qiling.
• Physics-Informed Extreme Learning Machines — yashirin og'irliklarni muzlatib, faqat output qatlamini o'qitish; o'qitish bitta linear solve'ga qisqaradi. Kamroq ifodali, ammo Black-Scholes o'lchami kichikligi sababli ahamiyatsiz bo'lishi mumkin.
• Operator learning (DeepONet, FNO) — yechimning o'zini emas, yechim operatorini o'rganish; yangi payoff tuzilmalari qayta o'qitishni talab qilmasligi uchun $(\sigma(\cdot), r(\cdot), \text{payoff}(\cdot)) \to V(\cdot,\cdot)$ ni aks ettirish. DeepSVM ga qarang.

Xulosa

PINN'lar chekli ayirmalar yoki Monte Carlo'ni almashtirmaydi. Bitta parametr to'plamidagi bitta past o'lchamli opsion uchun chekli ayirmalar yutadi va farq katta. PINN foydasiga holat tor va aniq: grid'lar ishlamay qoladigan yuqori o'lchamli modellar, book bo'ylab qayta ishlatiladigan parametrik yechimlar va narx bilan bir xil autodiff pass'dan olinadigan Greek'lar.

Bu post taqdim etadigan narsa — tarjima qatlami: Heston aralash hosilasi, Amerika erkin chegarasi va Merton sakrash integrali loss funksiyasidagi hadga qanday aylanishi. Hali taqdim etmaydigan narsa — hosil bo'lgan tarmoqlar hedging uchun yetarlicha aniq ekaniga dalil. Bu keyingi bosqich; u ishga tushmaguncha yuqoridagilarning barchasini tavsiya emas, derivatsiya deb biling.

Manbalar va qo'shimcha o'qish

• Raissi, M., Perdikaris, P., Karniadakis, G.E. (2019). Physics-informed neural networks: A deep learning framework for solving forward and inverse problems involving nonlinear partial differential equations. Journal of Computational Physics, 378, 686-707.
• Dhiman, A., Kaur, D. (2023). Physics Informed Neural Network for Option Pricing. arXiv preprint.
• Salvador, B. et al. (2023). Meshless methods for American option pricing through Physics-Informed Neural Networks. Engineering Analysis with Boundary Elements.
• Bai, G. et al. (2025). An uncertainty-aware physics-informed neural network solution for the Black-Scholes equation. arXiv preprint.
• Chen, Y. et al. (2025). Stochastic jump diffusion process informed neural networks for American option pricing under data scarcity. Applied Soft Computing.
• Benth, F.E. et al. (2025). DeepSVM: Learning Stochastic Volatility Models with Physics-Informed Deep Operator Networks. arXiv preprint.
• He, Y. et al. (2024). Finance-Informed Neural Network: Learning the Geometry of Option Pricing. arXiv preprint.
• MathWorks: Physics-Informed Neural Networks (PINNs) for Option Pricing. MATLAB Finance Blog, 2025.
• GitHub: BlackScholesPINN (PyTorch implementation).
• Raissi PINNs GitHub repository.