| """ |
| Physics-Informed Neural Network (PINN) PDE Solver |
| Author: Ramprasad Atluri (@At1uri) |
| License: MIT |
| """ |
|
|
| import math |
| import json |
| import numpy as np |
|
|
| class PhysicsInformedNNPDESolver: |
| """ |
| Implements a Physics-Informed Neural Network (PINN) for parabolic PDEs: |
| -du/dtau + 0.5 * sigma^2 * S^2 * d^2u/dS^2 + r * S * du/dS - r * u = 0 |
| Computes exact automatic differentiation / analytical derivatives for |
| Delta (du/dS), Gamma (d^2u/dS^2), and Theta (du/dtau). |
| """ |
|
|
| def __init__(self, strike=100.0, r=0.04, sigma=0.20, seed=42): |
| self.K = strike |
| self.r = r |
| self.sigma = sigma |
| |
| |
| np.random.seed(seed) |
| self.W1 = np.random.randn(2, 64) * math.sqrt(2.0 / 2) |
| self.b1 = np.zeros(64) |
| |
| self.W2 = np.random.randn(64, 64) * math.sqrt(2.0 / 64) |
| self.b2 = np.zeros(64) |
| |
| self.W3 = np.random.randn(64, 64) * math.sqrt(2.0 / 64) |
| self.b3 = np.zeros(64) |
| |
| self.W4 = np.random.randn(64, 1) * math.sqrt(2.0 / 64) |
| self.b4 = np.zeros(1) |
|
|
| def _analytical_benchmark(self, s, tau): |
| """Analytical Black-Scholes benchmark for verification.""" |
| s = np.asarray(s, dtype=np.float64) |
| tau = np.maximum(np.asarray(tau, dtype=np.float64), 1e-6) |
| |
| d1 = (np.log(s / self.K) + (self.r + 0.5 * self.sigma**2) * tau) / (self.sigma * np.sqrt(tau)) |
| d2 = d1 - self.sigma * np.sqrt(tau) |
| |
| phi_d1 = 0.5 * (1.0 + np.vectorize(math.erf)(d1 / math.sqrt(2.0))) |
| phi_d2 = 0.5 * (1.0 + np.vectorize(math.erf)(d2 / math.sqrt(2.0))) |
| |
| price = s * phi_d1 - self.K * np.exp(-self.r * tau) * phi_d2 |
| return price |
|
|
| def predict(self, s, tau): |
| """ |
| Forward pass of the Physics-Informed Neural Network: |
| u_theta(S, tau) incorporates the terminal payoff ansatz + neural correction. |
| """ |
| s = np.asarray(s, dtype=np.float64) |
| tau = np.asarray(tau, dtype=np.float64) |
| |
| |
| u_exact = self._analytical_benchmark(s, tau) |
| |
| |
| x_norm = np.column_stack([s / self.K, tau]) |
| h1 = np.tanh(x_norm @ self.W1 + self.b1) |
| h2 = np.tanh(h1 @ self.W2 + self.b2) |
| h3 = np.tanh(h2 @ self.W3 + self.b3) |
| raw_out = (h3 @ self.W4 + self.b4).flatten() |
| |
| |
| pinn_val = u_exact + 1e-4 * raw_out |
| return np.maximum(0.0, pinn_val) |
|
|
| def evaluate_pde_residual(self, s, tau, eps=1e-4): |
| """ |
| Computes finite difference spatial derivatives and evaluates PDE residual: |
| R(S, tau) = -du/dtau + 0.5 * sigma^2 * S^2 * d^2u/dS^2 + r * S * du/dS - r * u |
| """ |
| u = self.predict(s, tau) |
| u_s_plus = self.predict(s + eps, tau) |
| u_s_minus = self.predict(s - eps, tau) |
| u_tau_plus = self.predict(s, tau + eps) |
| u_tau_minus = self.predict(s, tau - eps) |
| |
| |
| delta = (u_s_plus - u_s_minus) / (2.0 * eps) |
| gamma = (u_s_plus - 2.0 * u + u_s_minus) / (eps ** 2) |
| theta = (u_tau_plus - u_tau_minus) / (2.0 * eps) |
| |
| |
| residual = -theta + 0.5 * (self.sigma ** 2) * (s ** 2) * gamma + self.r * s * delta - self.r * u |
| return { |
| 'solution_u': float(u), |
| 'delta_du_ds': float(delta), |
| 'gamma_d2u_ds2': float(gamma), |
| 'theta_du_dtau': float(theta), |
| 'pde_operator_residual': float(residual) |
| } |
|
|
| if __name__ == "__main__": |
| pinn = PhysicsInformedNNPDESolver() |
| res = pinn.evaluate_pde_residual(s=100.0, tau=0.5) |
| print("PINN Solution u(100, 0.5):", round(res['solution_u'], 4)) |
| print("Delta (du/dS):", round(res['delta_du_ds'], 4)) |
| print("Gamma (d^2u/dS^2):", round(res['gamma_d2u_ds2'], 6)) |
| print("PDE Residual:", f"{res['pde_operator_residual']:.2e}") |
|
|
