Redes Neurais Informadas pela Física para Preços de Opções

A parte interessante da aplicação de PINNs a derivativos não é o Black-Scholes. Black-Scholes tem forma fechada; uma rede que o reproduz é uma verificação de sanidade, não um resultado. A parte interessante é tudo o que não tem uma forma fechada e onde as diferenças finitas fogem do caminho: a EDP de dois fatores de Heston com sua parcial mista $\partial^2 V / \partial S \partial v$, o problema da fronteira livre americana e a equação integro-diferencial parcial de Merton, cujo termo integral acopla todos os pontos do domínio a todos os outros pontos.

Esta postagem é sobre como cada um deles entra em uma função de perda. Concretamente: o resíduo logarítmico do preço que torna o PINN de Black-Scholes treinável, a rede Heston de três entradas cuja derivada cruzada sai do autograd gratuitamente, o tratamento de penalidade versus duas redes do exercício inicial e uma quadratura de Gauss-Hermite que coloca a integral do salto dentro de um resíduo PDE.

O que não é é uma referência. Cada número abaixo que parece um resultado é um alvo ou uma citação e é marcado como tal. A passagem de medição tem escopo definido no final.

PINNs foram introduzidos por Raissi et al. (2019), e a mecânica já é abordada neste blog em The Navier-Stokes Problem, onde o mesmo truque do resíduo autogrado caça singularidades em equações de fluidos: o PDE se torna um termo de perda, o autodiff fornece derivadas exatas da rede em relação às suas entradas e nenhuma grade é construída. Aqui a única coisa que muda é qual PDE vai para a perda.

O EDP Black-Scholes como uma restrição física

A EDP Black-Scholes, sua recompensa terminal $\max(S-K,0)$, e o argumento de não arbitragem por trás dele são abordados em A Fórmula Black-Scholes — esta seção os assume e vai direto para a forma na qual uma rede pode realmente ser treinada.

Transformação log-preço

Trabalhando diretamente com $S$ é problemático: o domínio é $[0, \infty)$ e o PDE possui coeficientes variáveis. A transformação padrão $x = \ln(S)$ converte-o em uma forma de coeficiente constante:

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

Esta é uma equação de reação de convecção-difusão em $x \in (-\infty, \infty)$. Os coeficientes variáveis $S^2$ e $S$ desapareceram, o que é importante para uma rede: um resíduo cuja magnitude aumenta com $S^2$ é dominado pela extremidade do domínio e o otimizador gasta seu orçamento lá.

Perda de PINN para Black-Scholes

Deixe $u_\theta(x, t)$ seja a rede. Amostra $N_r$ pontos de colocação $(x_i, t_i)$ no interior, $N_b$ nas fronteiras e $N_0$ no horário do 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$

Cada derivada parcial é calculada via torch.autograd.grad com create_graph=True, então os gradientes fluem através do cálculo da derivada durante a retropropagação. Esse único sinalizador é todo o truque de implementação.

Implementação PyTorch

Os parâmetros abaixo têm sabor de criptografia e não de livro didático: $\sigma = 0.7$ e $T = 0.08$ (aproximadamente uma opção BTC de 30 dias) em vez da mesa de ações $\sigma = 0.2$, $T = 1.0$. Maturidade curta mais vol alto é o regime onde a torção do retorno é mais acentuada e onde o PINN é mais difícil de treinar – esse é o ponto.

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

Duas escolhas estruturais que valem a pena assinalar:

• Peso na condição terminal. O retorno ganha peso 10x porque define o problema. Sem uma aplicação forte, a rede pode satisfazer a EDP trivialmente, gerando zero em todos os lugares - a EDP homogênea tem infinitas soluções e a condição terminal é o que seleciona uma.
• Reamostragem de pontos de colocação a cada época. Os pontos são desenhados a cada etapa, o que atua como regularização estocástica no resíduo. A alternativa – um conjunto de pontos fixos – permite que a rede superajuste o resíduo nessas coordenadas exatas.

Estendendo-se ao modelo de volatilidade estocástica de Heston

Preços Black-Scholes com uma única constante $\sigma$, que é exatamente a suposição que a previsão de volatilidade GARCH(1,1) foi criada para rejeitar. Heston faz da volatilidade um segundo fator estocástico, a variância instantânea $v$:

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

onde $\kappa$ é a velocidade de reversão à média, $\theta$ a variação de longo prazo, $\xi$ o vol-de-vol, e $dW_1 \cdot dW_2 = \rho\,dt$.

O PDE de preços é bidimensional no estado:

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

É aqui que um método sem malha começa a parecer atraente. Um esquema de diferenças finitas precisa de uma grade em $(S, v, t)$ - um típico $200 \times 100 \times 500$ é $10^7$ nós. Adicione um terceiro fator estocástico, como taxas estocásticas, e a grade se tornará impraticável. Monte Carlo tem melhor dimensão, mas converge lentamente, especialmente para os gregos.

Arquitetura PINN para Heston

A rede recebe três entradas $(x, v, t)$ com $x = \ln S$. A parcial mista $\partial^2 u / \partial x \partial v$ – o termo que torna os esquemas de ADI estranhos – é mais um autograd.grad chamar:

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

Observe que u_xv é obtido diferenciando u_x em relação a v, reutilizando o gráfico construído pela primeira chamada. Simetria da parcial mista significa diferenciar u_v em relação a x deve fornecer o mesmo tensor; em float32 isso não acontecerá exatamente, e a lacuna é um diagnóstico barato para saber se o gráfico está se comportando.

Opções americanas e problemas de limite livre

As opções americanas acrescentam uma restrição ao exercício antecipado: o valor nunca deve cair abaixo do valor intrínseco. Isso transforma o PDE em um problema de fronteira livre, equivalentemente um problema de complementaridade 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$

onde $\mathcal{L}$ é o operador Black-Scholes e $\Phi(S)$ a recompensa. Duas maneiras de colocar isso em risco.

Método de penalidade

Substitua a restrição de complementaridade por uma penalidade suave:

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

com $\rho_p$ grande (normalmente $10^4$ para $10^6$). Quando $V$ cai abaixo do valor intrínseco, a penalidade força o retorno e a perda do PINN torna-se:

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

Nenhuma mudança de arquitetura, apenas um resíduo modificado. O custo é um novo hiperparâmetro com uma compensação de mau condicionamento: muito pequeno e a restrição é violada, muito grande e o cenário de perdas é dominado pelo termo de penalidade.

Abordagem direta de limite livre

Treine duas redes em conjunto: uma pelo preço $u_\theta(S, t)$, um para o limite ideal de exercício $S^*_\phi(t)$. A perda carrega o PDE na região de continuação, a condição de colagem suave na fronteira e o retorno na região de exercício. A fronteira surge como um resultado de primeira classe, que é o que você realmente deseja para proteger um livro americano.

Modelos de difusão de salto com PINNs

O modelo de Merton adiciona saltos de Poisson ao movimento geométrico browniano:

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

onde $J$ é um processo de Poisson composto com intensidade $\lambda$ e tamanhos de salto log-normais. O preço torna-se uma equação integro-diferencial parcial (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$

com $f(y)$ a densidade do multiplicador de salto.

A integral é o que quebra as diferenças finitas – ela acopla todos os pontos do domínio a todos os outros pontos, destruindo a estrutura em faixas na qual o solucionador se baseia. Um PINN não tem essa estrutura para perder. A integral é apenas mais um termo no resíduo, avaliado por quadratura em cada ponto de colocação, e como a rede é definida em todos os lugares, $V(Sy, t)$ é um passe livre em vez de uma interpolação:

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

O resíduo PIDE é então:

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

com $I[u]$ a aproximação da quadratura. Os custos do circuito n_quad passes extras para frente por etapa de treinamento, todos caindo no gráfico de autogradação - o preço real dos saltos é a memória, não a matemática.

Comparação com métodos tradicionais

As diferenças estruturais são reais e podem ser afirmadas sem referência:

As linhas de desempenho que normalmente estariam aqui – tempo de treinamento, latência de inferência, precisão – estão deliberadamente ausentes, porque medi-las é um trabalho aberto, não uma entrada de tabela.

Onde os PINNs vencem plausivelmente

Reavaliação em tempo real. Uma vez treinada, a avaliação é uma passagem direta sobre um lote, portanto, um livro inteiro é reavaliado em uma inicialização do kernel, em vez de uma solução por conjunto de parâmetros. Se isso supera um solucionador Crank-Nicolson bem ajustado em tamanhos de livros realistas é uma questão empírica e não medida aqui.

Modelos de alta dimensão. A volatilidade estocástica mais taxas estocásticas mais saltos tem 4+ dimensões, onde as diferenças finitas são efetivamente mortas. Os PINNs degradam-se normalmente em dimensão, sujeitos à dificuldade de treinamento.

Gregos contínuos. A rede é suave e diferenciável, então Delta, Gamma, Theta e Vega vêm do mesmo maquinário autogrado que o resíduo PDE - sem colisão e revalorização, sem ruído de diferença finita. Esta é a afirmação mais forte do post e também a que mais precisa de uma superfície Gamma medida por trás dela.

Soluções paramétricas. Parâmetros do modelo de alimentação ($\sigma$, $\kappa$, $\theta$) como entradas de rede permite que um PINN cubra uma família de modelos em vez de uma única calibração.

Onde os PINNs enfrentam dificuldades

Custo de treinamento. Para uma opção em um conjunto de parâmetros, a resolução de diferenças finitas termina antes que um PINN termine suas primeiras mil épocas.

Sem limites de erro. Diferenças finitas com a extrapolação de Richardson alcançam a precisão da máquina com uma ordem de convergência conhecida. Um PINN relata um valor de perda, que não é um limite de erro. Variantes conscientes da incerteza (Bai et al., 2025) atribuem intervalos de confiança, mas o campo é jovem.

Dificuldade de otimização. O cenário de perdas é muito não convexo e a ponderação entre PDE, limite e termos terminais é um problema de ajuste. A falha característica é uma rede que leva o resíduo do PDE a próximo de zero, ignorando totalmente as condições de contorno – uma solução perfeitamente válida para o problema errado.

Reprodutibilidade. Diferentes sementes, distribuições de colocação e configurações de otimizador podem resultar em soluções significativamente diferentes. A montagem ajuda e multiplica os custos.

Essas duas últimas são as partes deste post que mais vale a pena transformar em enredo, porque são modos de falha que qualquer um que reimplementar isso irá atingir.

O que ainda precisa ser medido

O estado honesto deste artigo: as formulações estão corretas e o código é executado, mas nada aqui foi avaliado no hardware ou nos dados desta mesa. A passagem que tornaria isso um resultado em vez de uma derivação:

1. Sup-norma e RMSE contra Black-Scholes de forma fechada em todo o $(S, t)$ grade, por semente, cinco sementes. A meta usual do folclore é a concordância com mais de 4 casas decimais; o objetivo é testar isso em $\sigma = 0.7$, $T = 0.08$ e publique as sementes onde falhar.
2. Erro Delta e Gama, não apenas erro de preço. Uma rede que combina preços com quatro dígitos com um ruído ruidoso $\Gamma$ é inútil para hedge, então Gama é o critério de aceitação.
3. Tempo de treinamento de relógio de parede e latência de inferência por opção para um livro de 10.000 opções, contra uma solução Crank-Nicolson do problema idêntico na mesma GPU.
4. Os modos de falha, reproduzidos deliberadamente. Reduza o peso da perda de limite até que a rede satisfaça o PDE e perca o limite; execute cinco sementes e trace a propagação. Ambos são baratos de produzir e mais úteis do que outra superfície de preço de aparência correta.
5. Ajuste às cotações reais do Deribit BTC ou, no mínimo, mantenha os parâmetros criptorrealistas acima, em vez de reverter para $\sigma = 0.2$, $T = 1.0$.
6. Escolhas de arquitetura e otimizador como descobertas, não como conselhos. Mais amplo versus mais profundo, tanh versus ReLU (a segunda derivada descontínua de ReLU deve destruir visivelmente o residual), $\lambda_{\text{IC}}$ varreduras, e Adam-então-L-BFGS versus Adam sozinho são todos experimentos de uma linha. Até que sejam executados, eles são folclore repetidos na literatura, e este post se recusa a repeti-los como recomendações.

As duas afirmações estruturais que sobrevivem sem medição, porque são propriedades da formulação e não de uma execução: usam coordenadas log-preço (o EDP torna-se coeficiente constante, o que é um facto sobre a álgebra), e pondera a condição terminal acima do termo EDP (o EDP homogéneo admite a solução zero, o que é um facto sobre o problema).

O que mais existe por aí

Instruções que vale a pena conhecer, nenhuma delas testada aqui:

• Amostragem de colocação adaptativa residual — coloque pontos onde o resíduo é grande, próximo ao ataque para Black-Scholes ou próximo ao limite de Feller para Heston, em vez de uniformemente. A implementação é curta:

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]

• Transfira o aprendizado entre datas e vencimentos — ajuste fino de um vizinho $(K, T)$ em vez de treinar do zero, manter uma biblioteca que cubra a cadeia de opções.
• Máquinas de aprendizado extremo informadas pela física — congela pesos ocultos, treina apenas a camada de saída, reduzindo o treinamento a uma solução linear. Menos expressivo, mas Black-Scholes é tão pouco dimensional que pode não importar.
• Aprendizado do operador (DeepONet, FNO) — aprenda o operador da solução em vez da solução, mapeando $(\sigma(\cdot), r(\cdot), \text{payoff}(\cdot)) \to V(\cdot,\cdot)$ portanto, as novas estruturas de remuneração não necessitam de reciclagem. Consulte DeepSVM.

Conclusão

Os PINNs não substituem diferenças finitas ou Monte Carlo. Para uma única opção de baixa dimensão em um único conjunto de parâmetros, as diferenças finitas vencem e não são próximas. O caso dos PINNs é restrito e específico: modelos de alta dimensão onde as grades morrem, soluções paramétricas reutilizadas em um livro e gregos que vêm da mesma passagem de autodiff que o preço.

O que esta postagem oferece é a camada de tradução - como a parcial mista de Heston, a fronteira livre americana e a integral de salto de Merton se tornam, cada uma, um termo em uma função de perda. O que ainda não fornece é evidência de que as redes resultantes sejam suficientemente precisas para se poder proteger. Essa é a próxima etapa e, até que seja executada, trate tudo acima como uma derivação e não como uma recomendação.

Referências e leituras adicionais

• Raissi, M., Perdikaris, P., Karniadakis, G.E. (2019). Redes neurais informadas pela física: uma estrutura de aprendizado profundo para resolver problemas diretos e inversos envolvendo equações diferenciais parciais não lineares. Jornal de Física Computacional, 378, 686-707.
• Dhiman, A., Kaur, D. (2023). Rede Neural Informada pela Física para Preços de Opções. pré-impressão arXiv.
• Salvador, B. et al. (2023). Métodos meshless para precificação de opções americanas por meio de redes neurais informadas pela física. Análise de Engenharia com Elementos de Fronteira. -Bai, G. et al. (2025). Uma solução de rede neural informada pela física e ciente da incerteza para a equação de Black-Scholes. pré-impressão arXiv. -Chen, Y. et al. (2025). Processo de difusão de salto estocástico informou redes neurais para precificação de opções americanas sob escassez de dados. Soft Computação Aplicada.
• Benth, FE et al. (2025). DeepSVM: Aprendendo modelos de volatilidade estocástica com redes de operadores profundos informadas pela física. pré-impressão arXiv.
• Ele, Y. et al. (2024). Rede Neural Informada sobre Finanças: Aprendendo a Geometria da Precificação de Opções. pré-impressão arXiv.
• MathWorks: Redes Neurais Informadas pela Física (PINNs) para Preços de Opções. Blog de finanças MATLAB, 2025.
• GitHub: BlackScholesPINN (implementação PyTorch).
• Repositório GitHub de PINNs da Raissi.