Physics-Informed Neural Networks for Options Pricing

Bagian menarik dari penerapan PINN pada derivatif bukanlah Black-Scholes. Black-Scholes memiliki bentuk tertutup; jaringan yang mereproduksinya adalah pemeriksaan kewajaran, bukan hasil. Bagian menariknya adalah segala sesuatu yang tidak memiliki bentuk tertutup dan tidak dapat lagi ditangani secara praktis oleh beda hingga: PDE dua faktor Heston dengan turunan parsial campurannya $\partial^2 V / \partial S \partial v$, masalah batas bebas opsi Amerika, dan persamaan integro-diferensial parsial Merton yang suku integralnya menghubungkan setiap titik dalam domain dengan semua titik lainnya.

Tulisan ini membahas cara memasukkan masing-masing hal tersebut ke dalam fungsi loss. Secara konkret: residual harga log yang membuat PINN Black-Scholes dapat dilatih, jaringan Heston dengan tiga input yang turunan silangnya diperoleh langsung dari autograd, penanganan exercise lebih awal melalui penalti versus dua jaringan, serta kuadratur Gauss-Hermite yang menempatkan integral lompatan di dalam residual PDE.

Tulisan ini bukan benchmark. Setiap angka di bawah yang tampak seperti hasil sebenarnya adalah target atau kutipan, dan ditandai demikian. Tahap pengukuran dijelaskan pada bagian akhir.

PINN diperkenalkan oleh Raissi et al. (2019), dan mekanismenya telah dibahas di blog ini dalam Masalah Navier-Stokes, tempat trik residual-autograd yang sama digunakan untuk mencari singularitas dalam persamaan fluida: PDE menjadi suku loss, autodiff menyediakan turunan eksak jaringan terhadap inputnya, dan tidak ada grid yang dibangun. Di sini, satu-satunya yang berubah adalah PDE yang dimasukkan ke dalam loss.

PDE Black-Scholes sebagai Kendala Fisika

PDE Black-Scholes, payoff terminalnya $\max(S-K,0)$, dan argumen tanpa arbitrase di baliknya dibahas dalam Rumus Black-Scholes — bagian ini menganggap semuanya sudah diketahui dan langsung membahas bentuk yang benar-benar dapat digunakan untuk melatih jaringan.

Transformasi harga log

Bekerja langsung dengan $S$ bermasalah: domainnya adalah $[0, \infty)$ dan PDE memiliki koefisien yang berubah-ubah. Transformasi standar $x = \ln(S)$ mengubahnya menjadi bentuk dengan koefisien konstan:

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

Ini adalah persamaan konveksi-difusi-reaksi pada $x \in (-\infty, \infty)$. Koefisien berubah-ubah $S^2$ dan $S$ telah hilang, yang penting bagi jaringan: residual yang besarnya berskala dengan $S^2$ akan didominasi ujung jauh domain dan optimizer menghabiskan anggarannya di sana.

Loss PINN untuk Black-Scholes

Misalkan $u_\theta(x, t)$ adalah jaringan. Ambil sampel $N_r$ titik kolokasi $(x_i, t_i)$ di bagian interior, $N_b$ di batas, dan $N_0$ pada waktu terminal:

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

Setiap turunan parsial dihitung melalui torch.autograd.grad dengan create_graph=True, sehingga gradien mengalir melalui perhitungan turunan selama backpropagation. Satu flag itulah seluruh trik implementasinya.

Implementasi PyTorch

Parameter di bawah bernuansa crypto, bukan parameter textbook: $\sigma = 0.7$ dan $T = 0.08$ (kira-kira opsi BTC 30 hari) alih-alih $\sigma = 0.2$, $T = 1.0$ yang lazim di desk saham. Maturitas pendek ditambah volatilitas tinggi adalah regime ketika kink payoff paling tajam dan PINN paling sulit dilatih — justru itulah tujuannya.

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

Ada dua pilihan struktural yang perlu diperhatikan:

• Bobot pada kondisi terminal. Payoff mendapat bobot 10x karena mendefinisikan masalah. Tanpa penegakan yang kuat, jaringan dapat memenuhi PDE secara trivial dengan menghasilkan nol di mana-mana — PDE homogen memiliki tak terhingga banyak solusi dan kondisi terminallah yang memilih salah satunya.
• Mengambil ulang titik kolokasi setiap epoch. Titik diambil ulang pada setiap langkah, yang berperan sebagai regularisasi stokastik pada residual. Alternatifnya — kumpulan titik tetap — memungkinkan jaringan overfit terhadap residual pada koordinat yang persis sama.

Memperluas ke Model Volatilitas Stokastik Heston

Black-Scholes menetapkan harga dengan satu $\sigma$ konstan, tepatnya asumsi yang hendak ditolak oleh peramalan volatilitas GARCH(1,1). Heston menjadikan volatilitas faktor stokastik kedua, yaitu varians sesaat $v$:

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

di mana $\kappa$ adalah kecepatan mean reversion, $\theta$ varians jangka panjang, $\xi$ vol-of-vol, dan $dW_1 \cdot dW_2 = \rho\,dt$.

PDE penetapan harganya berdimensi dua dalam state:

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

Di sinilah metode meshfree mulai tampak menarik. Skema beda hingga memerlukan grid dalam $(S, v, t)$ — ukuran tipikal $200 \times 100 \times 500$ berarti $10^7$ node. Tambahkan faktor stokastik ketiga, misalnya suku bunga stokastik, dan grid menjadi tidak praktis. Monte Carlo berskala lebih baik terhadap dimensi, tetapi konvergensinya lambat, terutama untuk Greeks.

Arsitektur PINN untuk Heston

Jaringan menerima tiga input $(x, v, t)$ dengan $x = \ln S$. Turunan parsial campuran $\partial^2 u / \partial x \partial v$ — suku yang membuat skema ADI rumit — hanya memerlukan satu pemanggilan autograd.grad tambahan:

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

Perhatikan bahwa u_xv diperoleh dengan menurunkan u_x terhadap v, menggunakan kembali graph yang dibangun oleh pemanggilan pertama. Simetri turunan parsial campuran berarti penurunan u_v terhadap x seharusnya menghasilkan tensor yang sama; dalam float32 hasilnya tidak akan persis sama, dan selisihnya merupakan diagnostik murah untuk memeriksa apakah graph bekerja dengan benar.

Opsi Amerika dan Masalah Batas Bebas

Opsi Amerika menambahkan kendala exercise lebih awal: nilainya tidak boleh berada di bawah nilai intrinsik. Ini mengubah PDE menjadi masalah batas bebas, atau secara ekuivalen masalah komplementaritas linear (LCP):

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

di mana $\mathcal{L}$ adalah operator Black-Scholes dan $\Phi(S)$ adalah payoff. Ada dua cara memasukkannya ke dalam loss.

Metode penalti

Ganti kendala komplementaritas dengan penalti halus:

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

dengan $\rho_p$ besar (biasanya $10^4$ hingga $10^6$). Saat $V$ turun di bawah nilai intrinsik, penalti memaksanya naik kembali, dan loss PINN menjadi:

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

Tidak ada perubahan arsitektur, hanya residual yang dimodifikasi. Konsekuensinya adalah hyperparameter baru dengan tradeoff conditioning yang buruk: terlalu kecil dan kendala dilanggar, terlalu besar dan lanskap loss didominasi suku penalti.

Pendekatan batas bebas langsung

Latih dua jaringan secara bersama: satu untuk harga $u_\theta(S, t)$, satu untuk batas exercise optimal $S^*_\phi(t)$. Loss memuat PDE di region kelanjutan, kondisi smooth pasting pada batas, dan payoff di region exercise. Batas tersebut menjadi output kelas satu, yaitu yang benar-benar dibutuhkan untuk melakukan hedging pada book Amerika.

Model Jump-Diffusion dengan PINN

Model Merton menambahkan lompatan Poisson pada gerak Brownian geometris:

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

di mana $J$ adalah proses Poisson majemuk dengan intensitas $\lambda$ dan ukuran lompatan log-normal. Penetapan harga menjadi persamaan integro-diferensial parsial (PIDE):

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

dengan $f(y)$ adalah densitas pengali lompatan.

Integral inilah yang merusak metode beda hingga — integral menghubungkan setiap titik dalam domain dengan semua titik lain, sehingga menghancurkan struktur berpita yang diandalkan solver. PINN tidak memiliki struktur tersebut, jadi tidak ada yang hilang. Integral hanyalah suku lain dalam residual, dievaluasi dengan kuadratur pada setiap titik kolokasi, dan karena jaringan terdefinisi di mana-mana, $V(Sy, t)$ dapat diperoleh melalui forward pass tanpa biaya tambahan alih-alih interpolasi:

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

Residual PIDE kemudian adalah:

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

dengan $I[u]$ adalah aproksimasi kuadratur. Loop tersebut membutuhkan n_quad forward pass tambahan pada setiap langkah pelatihan, semuanya masuk ke graph autograd — harga sebenarnya dari lompatan adalah memori, bukan matematika.

Perbandingan dengan Metode Tradisional

Perbedaan strukturalnya nyata dan dapat dijelaskan tanpa benchmark:

Baris performa yang biasanya ada di sini — waktu pelatihan, latensi inferensi, akurasi — sengaja tidak dicantumkan, karena pengukurannya adalah pekerjaan yang belum selesai, bukan isi tabel.

Di mana PINN kemungkinan unggul

Repricing real-time. Setelah dilatih, evaluasi adalah forward pass atas sebuah batch, sehingga seluruh book dapat dihitung ulang dalam satu peluncuran kernel, bukan satu penyelesaian untuk setiap set parameter. Apakah ini mengungguli solver Crank-Nicolson yang dituning dengan baik pada ukuran book realistis adalah pertanyaan empiris dan belum diukur di sini.

Model berdimensi tinggi. Volatilitas stokastik ditambah suku bunga stokastik dan lompatan menghasilkan 4+ dimensi, tempat beda hingga praktis tidak dapat digunakan. Kinerja PINN menurun secara bertahap ketika dimensi bertambah, dengan catatan pelatihannya lebih sulit.

Greeks kontinu. Jaringan bersifat halus dan dapat diturunkan, sehingga Delta, Gamma, Theta, dan Vega berasal dari mekanisme autograd yang sama dengan residual PDE — tanpa bump-and-revalue dan tanpa noise beda hingga. Ini adalah klaim terkuat dalam tulisan ini dan juga klaim yang paling membutuhkan permukaan Gamma hasil pengukuran sebagai pendukung.

Solusi parametrik. Memasukkan parameter model ($\sigma$, $\kappa$, $\theta$) sebagai input jaringan memungkinkan satu PINN mencakup sekumpulan model, bukan hanya satu kalibrasi.

Di mana PINN mengalami kesulitan

Biaya pelatihan. Untuk satu opsi pada satu set parameter, penyelesaian beda hingga sudah selesai sebelum PINN menuntaskan seribu epoch pertamanya.

Tidak ada batas error. Beda hingga dengan ekstrapolasi Richardson dapat mencapai presisi mesin dengan orde konvergensi yang diketahui. PINN melaporkan nilai loss, yang bukan batas error. Varian yang memperhitungkan ketidakpastian (Bai et al., 2025) menambahkan interval kepercayaan, tetapi bidang ini masih muda.

Kesulitan optimisasi. Lanskap loss sangat non-konveks dan pembobotan antara suku PDE, batas, dan terminal merupakan masalah tuning. Kegagalan yang khas adalah jaringan mendorong residual PDE mendekati nol sambil sepenuhnya mengabaikan kondisi batas — solusi yang sepenuhnya valid untuk masalah yang salah.

Reprodusibilitas. Seed, distribusi kolokasi, dan pengaturan optimizer yang berbeda dapat menghasilkan solusi yang secara bermakna berbeda. Ensemble membantu, tetapi juga melipatgandakan biaya.

Dua hal terakhir itulah bagian tulisan ini yang paling layak diubah menjadi plot, karena merupakan mode kegagalan yang akan ditemui siapa pun yang mengimplementasikan ulang metode ini.

Yang Masih Perlu Diukur

Kondisi jujur artikel ini: formulasinya benar dan kodenya berjalan, tetapi belum ada yang di-benchmark pada hardware atau data desk ini. Tahap yang akan menjadikannya hasil, bukan sekadar derivasi, adalah:

1. Sup-norm dan RMSE terhadap Black-Scholes bentuk tertutup di seluruh grid $(S, t)$, per seed, lima seed. Target yang biasa disebut adalah kesesuaian hingga 4+ angka desimal; yang perlu diuji adalah target tersebut pada $\sigma = 0.7$, $T = 0.08$, lalu publikasikan seed saat target gagal.
2. Error Delta dan Gamma, bukan hanya error harga. Jaringan yang mencocokkan harga hingga empat digit tetapi menghasilkan $\Gamma$ yang bising tidak berguna untuk hedging, jadi Gamma adalah kriteria penerimaan.
3. Waktu pelatihan wall-clock dan latensi inferensi per opsi untuk book berisi 10.000 opsi, dibandingkan dengan penyelesaian Crank-Nicolson atas masalah identik pada GPU yang sama.
4. Mode kegagalan yang direproduksi secara sengaja. Kurangi bobot loss batas sampai jaringan memenuhi PDE tetapi meleset dari batas; jalankan lima seed dan plot sebarannya. Keduanya murah dibuat dan lebih berguna daripada permukaan harga lain yang hanya tampak benar.
5. Fitting pada kuotasi BTC Deribit nyata, atau setidaknya pertahankan parameter bernuansa crypto di atas alih-alih kembali ke $\sigma = 0.2$, $T = 1.0$.
6. Pilihan arsitektur dan optimizer sebagai temuan, bukan saran. Wider-versus-deeper, tanh versus ReLU (turunan kedua ReLU yang diskontinu seharusnya terlihat merusak residual), sweep $\lambda_{\text{IC}}$, serta Adam-then-L-BFGS versus Adam saja semuanya merupakan eksperimen satu baris. Sebelum dijalankan, semuanya hanyalah folklore yang diulang dari literatur, dan tulisan ini menolak mengulanginya sebagai rekomendasi.

Dua klaim struktural yang tetap bertahan tanpa pengukuran, karena merupakan sifat formulasi dan bukan hasil suatu run: gunakan koordinat harga log (PDE menjadi berkoefisien konstan, yang merupakan fakta aljabar), dan beri bobot kondisi terminal lebih tinggi daripada suku PDE (PDE homogen memiliki solusi nol, yang merupakan fakta tentang masalahnya).

Apa Lagi yang Tersedia

Beberapa arah yang layak diketahui, tetapi belum diuji di sini:

• Sampling kolokasi adaptif terhadap residual — tempatkan titik di lokasi residual besar, dekat strike untuk Black-Scholes atau dekat batas Feller untuk Heston, bukan secara seragam. Implementasinya singkat:

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]

• Transfer learning lintas strike dan maturitas — lakukan fine-tuning dari $(K, T)$ terdekat alih-alih melatih dari awal, agar tersedia library yang mencakup option chain.
• Extreme Learning Machine Berbasis Fisika — bekukan bobot tersembunyi, latih hanya layer output, sehingga pelatihan berkurang menjadi satu penyelesaian linear. Ekspresivitasnya lebih rendah, tetapi Black-Scholes cukup berdimensi rendah sehingga mungkin tidak menjadi masalah.
• Pembelajaran operator (DeepONet, FNO) — pelajari operator solusi, bukan solusinya, dengan memetakan $(\sigma(\cdot), r(\cdot), \text{payoff}(\cdot)) \to V(\cdot,\cdot)$ sehingga struktur payoff baru tidak memerlukan pelatihan ulang. Lihat DeepSVM.

Kesimpulan

PINN tidak menggantikan beda hingga atau Monte Carlo. Untuk satu opsi berdimensi rendah pada satu set parameter, beda hingga menang dengan selisih yang jauh. Alasan menggunakan PINN bersifat sempit dan spesifik: model berdimensi tinggi yang membuat grid tidak dapat digunakan, solusi parametrik yang dipakai ulang di seluruh book, serta Greeks yang berasal dari pass autodiff yang sama dengan harga.

Yang diberikan tulisan ini adalah lapisan translasi — cara turunan parsial campuran Heston, batas bebas Amerika, dan integral lompatan Merton masing-masing menjadi suku dalam fungsi loss. Yang belum diberikan adalah bukti bahwa jaringan yang dihasilkan cukup akurat untuk digunakan dalam hedging. Itulah tahap berikutnya, dan sampai tahap tersebut dijalankan, anggap semua uraian di atas sebagai derivasi, bukan rekomendasi.

Referensi dan Bacaan Lanjutan

• 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.