Seçenek Fiyatlandırması için Fizik Bilgili Sinir Ağları

PINN'leri türevlere uygulamanın ilginç kısmı Black-Scholes değil. Black-Scholes'un kapalı bir formu vardır; onu yeniden üreten bir ağ bir sonuç değil, bir akıl sağlığı kontrolüdür. İlginç olan, kapalı bir forma sahip olmayan ve sonlu farkların ortadan kalktığı her şeydir: karma kısmili Heston iki faktörlü PDE $\partial^2 V / \partial S \partial v$, Amerikan serbest sınır problemi ve integral terimi tanım kümesindeki her noktayı diğer tüm noktalara bağlayan Merton'un kısmi integral diferansiyel denklemi.

Bu yazı bunların her birinin nasıl bir kayıp fonksiyonuna girdiğiyle ilgili. Somut olarak: Black-Scholes PINN'i eğitilebilir kılan log-fiyat artığı, çapraz türevi otograddan ücretsiz olarak düşen üç girişli Heston ağı, erken alıştırmanın ceza-iki ağ uygulaması ve atlama integralini bir PDE kalıntısının içine yerleştiren bir Gauss-Hermite karelemesi.

Bu bir kıyaslama değildir. Aşağıda sonuç gibi görünen her sayı ya bir hedeftir ya da alıntıdır ve öyle işaretlenmiştir. Ölçüm geçişinin kapsamı en sonunda belirlenir.

PINN'ler Raissi ve ark. (2019) ve mekanikler zaten bu blogda The Navier-Stokes Problemi bölümünde ele alınıyor; burada aynı otograd-artık hilesi akışkan denklemlerdeki tekillikleri arar: PDE bir kayıp terimi haline gelir, autodiff, girdilerine göre ağın tam türevlerini sağlar ve hiçbir ızgara oluşturulmaz. Burada değişen tek şey hangi PDE'nin kaybedileceğidir.

Fizik Kısıtlaması Olarak Black-Scholes PDE

Black-Scholes PDE, nihai getirisi $\max(S-K,0)$ve bunun arkasındaki arbitrajın olmadığı argümanı Black-Scholes Formülü'de ele alınmıştır. Bu bölüm bunları varsayar ve doğrudan bir ağın gerçekten üzerinde eğitim alabileceği biçime gider.

Günlük fiyat dönüşümü

Doğrudan çalışmak $S$ sorunlu: etki alanı $[0, \infty)$ ve PDE değişken katsayılara sahiptir. Standart dönüşüm $x = \ln(S)$ bunu sabit katsayılı bir forma dönüştürür:

$\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 bir konveksiyon-difüzyon-reaksiyon denklemidir. $x \in (-\infty, \infty)$. Değişken katsayılar $S^2$ Ve $S$ bir ağ için önemli olan, büyüklüğü ile ölçeklenen bir kalıntıdır. $S^2$ alanın en uç noktasının hakimiyetindedir ve optimize edici bütçesini orada harcar.

Black-Scholes için PINN kaybı

izin ver $u_\theta(x, t)$ ağ olsun. Örnek $N_r$ sıralama noktaları $(x_i, t_i)$ iç kısımda, $N_b$ sınırlar üzerinde ve $N_0$ terminal zamanında:

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

Her kısmi türev şu şekilde hesaplanır: torch.autograd.grad ile create_graph=Trueböylece gradyanlar geri yayılım sırasında türev hesaplaması boyunca akar. Bu tek bayrak tüm uygulama hilesidir.

PyTorch Uygulaması

Aşağıdaki parametreler ders kitabı yerine kripto aromalıdır: $\sigma = 0.7$ Ve $T = 0.08$ (kabaca 30 günlük bir BTC seçeneği) özsermaye masası yerine $\sigma = 0.2$, $T = 1.0$. Kısa vade artı yüksek hacim, kazanç bükülmesinin en keskin olduğu ve PINN'in eğitilmesinin en zor olduğu rejimdir; asıl mesele de budur.

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

İşaretlemeye değer iki yapısal seçenek:

• Son koşuldaki ağırlık. Sorunu tanımladığı için getiri 10x ağırlık alır. Güçlü bir uygulama olmadan ağ, her yerde sıfır çıktısı vererek PDE'yi önemsiz bir şekilde karşılayabilir - homojen PDE'nin sonsuz sayıda çözümü vardır ve birini seçen terminal koşuludur.
• Her dönemde sıralama noktalarının yeniden örneklenmesi. Noktalar her adımda yeni bir şekilde çizilir ve bu, artık üzerinde stokastik düzenleme görevi görür. Alternatif - sabit bir nokta seti - ağın bu kesin koordinatlardaki kalıntıyı aşmasına olanak tanır.

Heston Stokastik Volatilite Modeline Genişletme

Tek sabitli Black-Scholes fiyatları $\sigma$, bu da tam olarak GARCH(1,1) oynaklık tahmininin reddetmek için oluşturulduğu varsayımdır. Heston, oynaklığı ikinci stokastik faktör olan anlık varyans haline getiriyor $v$:

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

Neresi $\kappa$ ortalama geri dönüş hızıdır, $\theta$ uzun vadeli varyans, $\xi$ hacim-hacim ve $dW_1 \cdot dW_2 = \rho\,dt$.

Fiyatlandırma PDE'si iki boyutludur:

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

Ağsız bir yöntemin çekici görünmeye başladığı yer burasıdır. Sonlu fark şemasının bir ızgaraya ihtiyacı vardır $(S, v, t)$ — tipik bir $200 \times 100 \times 500$ öyle $10^7$ düğümler. Stokastik oranlar gibi üçüncü bir stokastik faktör eklediğinizde ızgara kullanışsız hale gelir. Monte Carlo boyut olarak daha iyi ölçekleniyor ancak özellikle Yunanlılar için yavaş yavaş yakınlaşıyor.

Heston için PINN mimarisi

Ağ üç giriş alır $(x, v, t)$ ile $x = \ln S$. Karışık kısmi $\partial^2 u / \partial x \partial v$ - ADI planlarını tuhaf hale getiren terim - bir tane daha autograd.grad Arama:

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

Dikkat u_xv farklılaştırılmasıyla elde edilir u_x göre v, ilk çağrı tarafından oluşturulan grafiğin yeniden kullanılması. Karışık kısmi simetri, farklılaşma anlamına gelir u_v göre x aynı tensörü vermelidir; float32'de tam olarak öyle olmayacak ve boşluk, grafiğin davranıp davranmadığına dair ucuz bir teşhistir.

Amerikan Opsiyonları ve Serbest Sınır Sorunları

Amerikan opsiyonları erken uygulama kısıtlamasını da beraberinde getiriyor: değer hiçbir zaman içsel değerin altına düşmemelidir. Bu, PDE'yi serbest sınır problemine, eşdeğer olarak doğrusal tamamlayıcılık problemine (LCP) dönüştürür:

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

Neresi $\mathcal{L}$ Black-Scholes operatörüdür ve $\Phi(S)$ getirisi. Bunu zarara sokmanın iki yolu.

Ceza yöntemi

Tamamlayıcılık kısıtlamasını yumuşak bir cezayla değiştirin:

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

ile $\rho_p$ büyük (genellikle $10^4$ ile $10^6$). Ne zaman $V$ İçsel seviyenin altına düşerse, ceza onu tekrar yukarıya zorlar ve PINN kaybı şu şekilde olur:

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

Mimari değişiklik yok, yalnızca değiştirilmiş bir kalıntı. Maliyet, kötü koşullandırma değiş tokuşuna sahip yeni bir hiper parametredir: çok küçükse kısıtlama ihlal edilir, çok büyükse ve kayıp ortamına ceza süresi hakimdir.

Doğrudan serbest sınır yaklaşımı

İki ağı ortaklaşa eğitin: biri fiyata $u_\theta(S, t)$, optimum egzersiz sınırı için bir tane $S^*_\phi(t)$. Kayıp, devam bölgesindeki PDE'yi, sınırdaki düzgün geçme durumunu ve egzersiz bölgesindeki getiriyi taşır. Sınır birinci sınıf bir çıktı olarak ortaya çıkıyor ki bu aslında bir Amerikan kitabını hedge etmek için istediğiniz şeydir.

PINN'li Atlama Difüzyon Modelleri

Merton'un modeli geometrik Brown hareketine Poisson sıçramalarını ekliyor:

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

Neresi $J$ yoğunluğu olan bileşik bir Poisson sürecidir $\lambda$ ve log-normal atlama boyutları. Fiyatlandırma kısmi bir integral diferansiyel denklem (PIDE) haline gelir:

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

ile $f(y)$ atlama çarpanının yoğunluğu.

İntegral sonlu farkları ortadan kaldıran şeydir; alandaki her noktayı diğer tüm noktalara bağlayarak çözücünün güvendiği bantlı yapıyı yok eder. Bir PINN'in kaybedecek bir yapısı yoktur. İntegral, artıktaki başka bir terimdir, her sıralama noktasında kareleme ile değerlendirilir ve ağ her yerde tanımlandığı için, $V(Sy, t)$ enterpolasyondan ziyade serbest ileri geçiştir:

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

PIDE artığı o zaman:

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

ile $I[u]$ karesel yaklaşım. Döngü maliyetleri n_quad Antrenman adımı başına ekstra ileri paslar, bunların hepsi otograd grafiğine giriyor; sıçramaların gerçek bedeli matematik değil, hafızadır.

Geleneksel Yöntemlerle Karşılaştırma

Yapısal farklılıklar gerçektir ve bir kıyaslama yapılmadan ifade edilebilir:

Normalde burada yer alacak performans satırları (eğitim süresi, çıkarım gecikmesi, doğruluk) kasıtlı olarak yoktur çünkü bunları ölçmek bir tablo girişi değil, açık çalışmadır.

PINN'lerin makul bir şekilde kazandığı yer

Gerçek zamanlı yeniden fiyatlandırma. Eğitildikten sonra değerlendirme, bir grup üzerinden ileriye doğru yapılan bir geçiştir; dolayısıyla kitabın tamamı, parametre seti başına bir çözüm yerine tek bir çekirdek başlatma işleminde yeniden fiyatlandırılır. Bunun gerçekçi kitap boyutlarında iyi ayarlanmış bir Crank-Nicolson çözücüsünden üstün olup olmadığı ampirik bir sorudur ve burada ölçülmemiştir.

Yüksek boyutlu modeller. Stokastik volatilite artı stokastik oranlar artı sıçramalar, sonlu farkların fiilen ölü olduğu 4+ boyuttur. PINN'lerin boyutu, eğitim zorluğuna bağlı olarak incelikle bozulur.

Sürekli Yunanlılar. Ağ düzgün ve farklılaştırılabilir olduğundan Delta, Gamma, Theta ve Vega PDE kalıntısıyla aynı otograd makineden gelir; çarpma ve yeniden değerleme yok, sonlu fark gürültüsü yok. Bu, yazıdaki en güçlü iddia ve aynı zamanda arkasında ölçülü bir Gama yüzeyine en çok ihtiyaç duyulan iddia.

Parametrik çözümler. Besleme modeli parametreleri ($\sigma$, $\kappa$, $\theta$) ağ girişleri, tek bir kalibrasyon yerine bir PINN'in bir model ailesini kapsamasına olanak tanır.

PINN'lerin mücadele ettiği yer

Eğitim maliyeti. Bir parametre setindeki bir seçenek için, PINN ilk bin dönemini tamamlamadan sonlu farkların çözümü biter.

Hata sınırı yok. Richardson ekstrapolasyonuyla sonlu farklar, bilinen bir yakınsama sırası ile makine hassasiyetine ulaşır. PINN, hata sınırı olmayan bir kayıp değeri bildirir. Belirsizliğe duyarlı değişkenler (Bai ve diğerleri, 2025) Güven aralıklarını ekleyin, ancak alan genç.

Optimizasyon zorluğu. Kayıp manzarası fena halde dışbükey değildir ve PDE, sınır ve terminal terimleri arasındaki ağırlıklandırma bir ayarlama sorunudur. Karakteristik başarısızlık, sınır koşullarını tamamen göz ardı ederek PDE kalıntısını sıfıra yakın bir noktaya getiren bir ağdır; yanlış soruna tamamen geçerli bir çözüm.

Tekrarlanabilirlik. Farklı tohumlar, sıralama dağılımları ve optimize edici ayarları anlamlı derecede farklı çözümlere yol açabilir. Birleştirme maliyeti artırır ve artırır.

Bu son ikisi, bu yazının olay örgüsüne dönüştürülmeye değer kısımlarıdır, çünkü bunlar, bunu yeniden uygulayan herkesin karşılaşacağı başarısızlık modlarıdır.

Hala Ölçülmesi Gereken Şeyler

Bu makalenin dürüst hali: formülasyonlar doğru ve kod çalışıyor, ancak buradaki hiçbir şey bu masanın donanımı veya bu masanın verileriyle karşılaştırılmamıştır. Bunu bir türetme yerine sonuç haline getirecek geçiş:

1. Kapalı formdaki Black-Scholes'a karşı destek normu ve RMSE $(S, t)$ ızgara, tohum başına beş tohum. Olağan folklor hedefi 4'ten fazla ondalık basamağa uyum sağlamaktır; önemli olan bunu test etmektir $\sigma = 0.7$, $T = 0.08$ ve başarısız olduğu yerlerde tohumları yayınlayın.
2. Delta ve Gama hatası, sadece fiyat hatası değil. Fiyatları dört haneli olarak gürültülü bir şekilde eşleştiren bir ağ $\Gamma$ riskten korunma açısından faydasız olduğundan kabul kriteri Gama'dır.
3. 10.000 seçenekli bir kitap için duvar saati eğitim süresi ve seçenek başına çıkarım gecikmesi, aynı GPU'da aynı sorunun Crank-Nicolson çözümüne karşı.
4. Hata modları kasıtlı olarak yeniden üretilmiştir. Ağ PDE'yi karşılayana ve sınırı kaçırana kadar sınır kaybını azaltın; beş tohum çalıştırın ve yayılmayı planlayın. Her ikisinin de üretimi ucuzdur ve diğer doğru görünen fiyat yüzeylerinden daha kullanışlıdır.
5. Gerçek Deribit BTC fiyat tekliflerine uyun veya en azından kripto-gerçekçi parametreleri geri dönmek yerine yukarıda tutun $\sigma = 0.2$, $T = 1.0$.
6. Mimari ve optimize edici seçenekleri tavsiye olarak değil, bulgu olarak sunulur. Daha geniş ve daha derin, tanh ReLU'ya karşı (ReLU'nun süreksiz ikinci türevi, kalıntıyı gözle görülür şekilde mahvetmelidir), $\lambda_{\text{IC}}$ taramalar ve Adam-sonra-L-BFGS'ye karşı tek başına Adam'ın hepsi tek hatlı deneylerdir. Yayınlanıncaya kadar bunlar literatürden tekrarlanan folklorlardır ve bu yazı onları tavsiye olarak tekrarlamayı reddediyor.

Ölçülmeden varlığını sürdüren iki yapısal iddia, çünkü bunlar bir çalıştırmanın değil formülasyonun özellikleridir: log-fiyat koordinatlarını kullanın (PDE, cebirle ilgili bir gerçek olan sabit katsayı haline gelir) ve terminal koşulunu PDE teriminin üzerinde ağırlıklandırın (homojen PDE, problemle ilgili bir gerçek olan sıfır çözümünü kabul eder).

Orada Başka Neler Var

Bilmeye değer talimatlar, hiçbiri burada test edilmedi:

• Artık-adaptif sıralama örneklemesi — tekdüze bir dağılım yerine, artığın büyük olduğu, Black-Scholes için doğrultuya yakın veya Heston için Feller sınırına yakın noktalar yerleştirin. Uygulama kısadır:

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]

• Öğrenimleri farklı vadeler ve vadeler arasında aktarın — bir komşudan ince ayar yapın $(K, T)$ Sıfırdan eğitim yerine seçenek zincirini kapsayan bir kütüphaneyi sürdürmek.
• Fizik Bilgili Ekstrem Öğrenme Makineleri — gizli ağırlıkları dondurun, yalnızca çıktı katmanını eğitin ve eğitimi tek bir doğrusal çözüme indirin. Daha az etkileyici, ancak Black-Scholes önemli olmayacak kadar düşük boyutlu.
• Operatör öğrenimi (DeepONet, FNO) — çözüm, haritalama yerine çözüm operatörünü öğrenin $(\sigma(\cdot), r(\cdot), \text{payoff}(\cdot)) \to V(\cdot,\cdot)$ dolayısıyla yeni kazanç yapılarının yeniden eğitime ihtiyacı yoktur. Bkz. DeepSVM.

Sonuç

PINN'ler sonlu farkların veya Monte Carlo'nun yerini almaz. Tek bir parametre setinde tek bir düşük boyutlu seçenek için sonlu farklar kazanır ve yakın değildir. PINN'ler için durum dar ve spesifiktir: ızgaraların öldüğü yüksek boyutlu modeller, bir kitapta yeniden kullanılan parametrik çözümler ve fiyatla aynı otomatik fark geçişinden gelen Yunanlar.

Bu yazının sunduğu şey, çeviri katmanıdır - Heston karma kısmi, Amerika serbest sınırı ve Merton sıçrama integralinin her birinin nasıl bir kayıp fonksiyonunda terim haline geldiği. Henüz ortaya çıkan ağların riskten korunmak için yeterince doğru olduğuna dair kanıt sunmuyor. Bu bir sonraki geçiştir ve bu geçiş gerçekleşene kadar yukarıdaki her şeye bir öneriden ziyade bir türetme olarak davranın.

Referanslar ve İlave Okumalar

• Raissi, M., Perdikaris, P., Karniadakis, G.E. (2019). Fizik bilgili sinir ağları: Doğrusal olmayan kısmi diferansiyel denklemler içeren ileri ve ters problemleri çözmeye yönelik derin bir öğrenme çerçevesi. Hesaplamalı Fizik Dergisi, 378, 686-707.
• Dhiman, A., Kaur, D. (2023). Seçenek Fiyatlandırması için Fizik Bilgili Sinir Ağı. arXiv ön baskısı.
• Salvador, B. ve ark. (2023). Fizik Bilgili Sinir Ağları aracılığıyla Amerikan opsiyon fiyatlandırması için ağsız yöntemler. Sınır Elemanlarıyla Mühendislik Analizi. -Bai, G. ve ark. (2025). Black-Scholes denklemi için belirsizliğin farkında, fizik bilgili bir sinir ağı çözümü. arXiv ön baskısı.
• Chen, Y. ve ark. (2025). Stokastik sıçrama yayılma süreci, veri kıtlığı altında Amerikan opsiyon fiyatlandırması için sinir ağlarını bilgilendirdi. Uygulamalı Yazılım Hesaplama.
• Benth, F.E. ve diğerleri. (2025). DeepSVM: Fizik Bilgisine Sahip Derin Operatör Ağlarıyla Stokastik Volatilite Modellerini Öğrenme. arXiv ön baskısı.
• O, Y. ve ark. (2024). Finans Bilgili Sinir Ağı: Opsiyon Fiyatlandırmasının Geometrisini Öğrenmek. arXiv ön baskısı.
• MathWorks: Seçenek Fiyatlandırması için Fizik Bilgili Sinir Ağları (PINN'ler). MATLAB Finans Blogu, 2025.
• GitHub: BlackScholesPINN (PyTorch uygulaması).
• Raissi PINN'lerin GitHub deposu.