Redes Neurais Informadas por Física

Visão geral

Redes Neurais Informadas pela Física (Physics-Informed Neural Networks, PINNs) são uma família de métodos que usam Redes Neurais para aproximar soluções de equações diferenciais parciais (partial differential equations, PDEs; EDPs) e problemas correlatos com restrições, incorporando a física conhecida ao objetivo de treinamento. Em vez de aprender apenas a partir de pares entrada–saída rotulados, PINNs exploram:

  • Equações governantes (governing equations) (por exemplo, leis de conservação, relações constitutivas)
  • Condições de contorno (boundary conditions, BCs) e condições iniciais (initial conditions, ICs)
  • Dados de medição (measurement data) opcionais (ruidosos e/ou esparsos)

A ideia central é simples: representar a solução desconhecida (u(x,t)) (e, às vezes, parâmetros desconhecidos) com uma rede neural e, então, penalizar violações da EDP e das restrições na função de perda (loss function). O treinamento usa Retropropagação, com diferenciação automática (automatic differentiation, autodiff) fornecendo as derivadas necessárias para avaliar resíduos da EDP.

PINNs são especialmente atraentes quando:

  • Dados são escassos ou caros (experimentos, simulações de alta fidelidade)
  • Restrições de EDP são conhecidas e confiáveis
  • O domínio é irregular ou de alta dimensão (onde malhas são difíceis)
  • Você quer um único modelo substituto diferenciável (differentiable surrogate) para simulação, inferência e otimização

Configuração de problema restrito por EDP

Um problema direto típico de EDP é:

[ \mathcal{F}\big(x,t,u,\nabla u,\nabla^2 u,\dots;\theta\big)=0,\quad (x,t)\in \Omega ]

com condições de contorno e iniciais como:

[ \mathcal{B}(x,t,u,\nabla u)=0,\quad (x,t)\in \partial\Omega,\qquad u(x,0)=u_0(x) ]

Aqui:

  • (u) é o campo desconhecido (escalar ou vetorial)
  • (\Omega) é o domínio espaço-temporal (ou apenas espacial para problemas estacionários)
  • (\theta) pode incluir parâmetros físicos (difusividade, viscosidade, módulos elásticos), às vezes desconhecidos

Uma PINN aproxima (u) com uma rede neural:

[ u_\phi(x,t) \approx u(x,t) ]

onde (\phi) são pesos treináveis.

Formulação central de PINNs: “física na perda”

Perda baseada em resíduo (residual-based loss)

Defina o resíduo da EDP (PDE residual) em um ponto ((x,t)):

[ r_\phi(x,t) = \mathcal{F}\big(x,t,u_\phi,\nabla u_\phi,\nabla^2 u_\phi,\dots;\theta\big) ]

Então o objetivo de treinamento tipicamente combina múltiplos termos:

[ \mathcal{L}(\phi) = \lambda_{pde},\mathbb{E}{(x,t)\sim \Omega}\left[|r\phi(x,t)|^2\right]

  • \lambda_{bc},\mathbb{E}{(x,t)\sim \partial\Omega}\left[| \mathcal{B}\phi(x,t)|^2\right]
  • \lambda_{ic},\mathbb{E}{x\sim \Omega_0}\left[|u\phi(x,0)-u_0(x)|^2\right]
  • \lambda_{data},\mathbb{E}{(x,t)\sim \mathcal{D}}\left[|u\phi(x,t)-\hat{u}|^2\right] ]

Isso normalmente é implementado amostrando conjuntos finitos de pontos:

  • Pontos de colocalização (collocation points) no interior para o resíduo da EDP
  • Pontos de contorno/iniciais para os termos de condições de contorno/condições iniciais
  • Medições rotuladas opcionais (\mathcal{D})

O treinamento então usa variantes de Descida do Gradiente (frequentemente Adam seguido de métodos quasi-Newton (quasi-Newton methods) como L-BFGS).

Restrições suaves vs. rígidas

PINNs normalmente impõem restrições de uma entre duas formas:

  1. Restrições suaves (soft constraints) (método de penalidade (penalty method))
    Adiciona erros de condições de contorno/condições iniciais à perda (mais comum).

    • Prós: fácil de implementar; flexível
    • Contras: balancear os pesos da perda pode ser difícil; as restrições podem ser violadas se forem pouco ponderadas

  2. Restrições rígidas (hard constraints) (solução tentativa (trial solution) / arquitetura com restrições (constrained architecture))
    Constrói (u_\phi) de modo que as condições de contorno/condições iniciais sejam satisfeitas por construção. Exemplo para uma condição de contorno de Dirichlet (Dirichlet BC) 1D (u(0,t)=a), (u(1,t)=b):

    [ u_\phi(x,t)=a(1-x)+bx + x(1-x),N_\phi(x,t) ]

    onde (N_\phi) é uma rede neural não restrita.

    • Prós: garante as restrições exatamente
    • Contras: pode ser complicado para geometrias complexas ou condições de Neumann/condições mistas (mixed conditions)

Na prática, muitos fluxos de trabalho usam restrições suaves com ponderação cuidadosa ou estratégias adaptativas.

Diferenciação automática para resíduos de EDP

Para avaliar (r_\phi(x,t)), você precisa de derivadas como (u_t), (u_x), (u_{xx}) etc. PINNs dependem de diferenciação automática, que pode computar derivadas exatas da saída da rede em relação às entradas (até erro de ponto flutuante).

Por que a diferenciação automática é central

  • Evita ruído de derivadas por diferenças finitas (finite-difference)
  • Funciona em qualquer dimensão
  • Mantém todo o solucionador diferenciável (útil para problemas inversos e controle ótimo)

Considerações práticas

  • Derivadas de ordem superior (higher-order derivatives) podem ser caras e numericamente delicadas (por exemplo, (u_{xxxx}), derivadas parciais mistas).
  • Funções de ativação importam: ativações suaves (por exemplo, tanh, sin, softplus) frequentemente funcionam melhor para EDPs do que ReLU, que não é duas vezes diferenciável.
  • Fique atento a patologias de gradiente (gradient pathologies): termos do resíduo da EDP podem causar otimização rígida e gradientes conflitantes entre componentes da perda.

Frameworks comumente usados: PyTorch, JAX, TensorFlow. Muitas bibliotecas de PINN encapsulam esses frameworks (por exemplo, DeepXDE, NVIDIA Modulus).

Estratégias de colocalização e amostragem

PINNs aproximam integrais/esperanças usando pontos amostrados. Essa amostragem pode dominar o desempenho.

Conjuntos comuns de pontos

  • Amostragem aleatória uniforme (uniform random sampling) no domínio
  • Amostragem por hipercubo latino (Latin Hypercube Sampling, LHS) para melhor cobertura em dimensões moderadas
  • Sequências quase aleatórias (quasi-random sequences) (Sobol, Halton) para melhor preenchimento do espaço
  • Grades estruturadas (structured grids) quando o domínio é simples (pode melhorar a estabilidade)

Amostragem adaptativa (adaptive sampling) (refinamento baseado em resíduo (residual-based refinement))

Uma melhoria frequente é adicionar pontos de forma adaptativa onde o resíduo da EDP é grande:

  1. Treinar em um conjunto inicial de pontos de colocalização
  2. Avaliar o resíduo em um conjunto candidato
  3. Reamostrar mais pontos onde (|r_\phi|) é alto
  4. Continuar o treinamento

Isso se assemelha a um indicador de erro em métodos numéricos clássicos e frequentemente ajuda com choques, camadas-limite e fenômenos localizados.

Ideias de currículo e continuação

Relacionado a Aprendizado por Currículo, alguns fluxos de trabalho com PINNs aumentam gradualmente a dificuldade:

  • Começar com amostragem grosseira e depois refinar
  • Começar com horizontes de tempo menores e depois expandir (“PINNs com marcha no tempo (time marching PINNs)”)
  • Aumentar os pesos de perda no resíduo da EDP após ajustar restrições/dados

Considerações de treinamento e pontos de dor comuns

Balanceamento e ponderação de perdas

PINNs são problemas multiobjetivo: resíduo da EDP, condições de contorno/condições iniciais e termos de dados podem ter escalas muito diferentes. Uma ponderação ruim pode levar a:

  • Bom ajuste no contorno, mas baixa satisfação da EDP (ou vice-versa)
  • Convergência lenta ou estagnação

Abordagens comuns:

  • Ajuste manual dos pesos (\lambda)
  • Normalização (normalization) de entradas/saídas e termos de resíduo
  • Pesos adaptativos (adaptive weights) baseados em magnitudes de gradiente (por exemplo, equalizando normas de gradiente entre termos)
  • Otimizadores/agendas separados para termos diferentes (menos comum, mas às vezes útil)

Otimizadores (optimizers): Adam + L-BFGS é uma receita clássica

Um padrão amplamente usado:

  1. Rodar Adam para exploração e redução rápida da perda
  2. Trocar para L-BFGS para convergência mais rápida a um ótimo local (quando funciona)

Ressalva: L-BFGS pode consumir muita memória e ser sensível a ruído de batch; funciona melhor com treinamento relativamente estável em batch completo ou batches grandes.

Viés espectral e mapeamentos de características

Perceptrons multicamadas (multilayer perceptrons, MLPs) padrão frequentemente aprendem primeiro componentes de baixa frequência (“viés espectral (spectral bias)”), o que pode prejudicar problemas com gradientes acentuados ou soluções de alta frequência. Mitigações práticas:

  • Características de Fourier (Fourier features) / embeddings sinusoidais (sinusoidal embeddings) das entradas
  • Redes sinusoidais no estilo SIREN (SIREN-style sinusoidal networks) (em alguns cenários)
  • Decomposição de domínio (domain decomposition) (treinar redes separadas em subdomínios)
  • Arquiteturas com conexões de atalho (skip connections) para facilitar a otimização (do tipo ResNet (ResNet-like))

EDPs rígidas (stiff PDEs) e física multiescala (multi-scale physics)

PINNs podem ter dificuldades com:

  • Coeficientes muito pequenos/grandes (por exemplo, escoamentos com alto número de Reynolds)
  • Camadas-limite finas
  • Formação de choques (descontinuidades)

Mitigações incluem:

  • Adimensionalização (non-dimensionalization) / escalonamento (scaling)
  • Amostragem adaptativa perto das camadas
  • Uso de formas fracas/variacionais (weak/variational forms) (veja abaixo)
  • Métodos híbridos (hybrid methods) que combinam solucionadores clássicos com modelos substitutos de PINN

Exemplo prático: PINN para a equação do calor 1D

Considere a equação do calor 1D em (x\in[0,1]), (t\in[0,T]):

[ u_t = \alpha u_{xx} ]

com condição inicial: (u(x,0)=\sin(\pi x)) e condições de contorno: (u(0,t)=u(1,t)=0).

Uma PINN modela (u_\phi(x,t)). O resíduo é:

[ r_\phi(x,t) = u_t(x,t) - \alpha u_{xx}(x,t) ]

Abaixo está um esboço mínimo no estilo PyTorch (ilustrativo, não pronto para produção):

import torch
import torch.nn as nn

class MLP(nn.Module):
    def __init__(self, width=64, depth=4):
        super().__init__()
        layers = [nn.Linear(2, width), nn.Tanh()]
        for _ in range(depth - 1):
            layers += [nn.Linear(width, width), nn.Tanh()]
        layers += [nn.Linear(width, 1)]
        self.net = nn.Sequential(*layers)

    def forward(self, x, t):
        xt = torch.cat([x, t], dim=1)  # shape (N,2)
        return self.net(xt)

def gradients(y, x):
    return torch.autograd.grad(
        y, x, grad_outputs=torch.ones_like(y),
        create_graph=True, retain_graph=True
    )[0]

alpha = 0.1
model = MLP()
opt = torch.optim.Adam(model.parameters(), lr=1e-3)

# Sample collocation points (interior)
Nf = 5000
x_f = torch.rand(Nf, 1, requires_grad=True)
t_f = torch.rand(Nf, 1, requires_grad=True)

# Boundary points
Nb = 500
t_b = torch.rand(Nb, 1)
x0 = torch.zeros(Nb, 1)
x1 = torch.ones(Nb, 1)

# Initial points
Ni = 500
x_i = torch.rand(Ni, 1)
t0 = torch.zeros(Ni, 1)

for step in range(2000):
    opt.zero_grad()

    # PDE residual
    u = model(x_f, t_f)
    u_t = gradients(u, t_f)
    u_x = gradients(u, x_f)
    u_xx = gradients(u_x, x_f)
    r = u_t - alpha * u_xx
    loss_pde = (r**2).mean()

    # Boundary loss
    u0 = model(x0, t_b)
    u1 = model(x1, t_b)
    loss_bc = (u0**2).mean() + (u1**2).mean()

    # Initial loss
    ui = model(x_i, t0)
    u0_true = torch.sin(torch.pi * x_i)
    loss_ic = ((ui - u0_true)**2).mean()

    loss = loss_pde + loss_bc + loss_ic
    loss.backward()
    opt.step()

Em uma implementação real, você normalmente adicionaria:

  • Escalonamento de entrada (por exemplo, mapear (x,t) para ([-1,1]))
  • Amostragem melhor (Sobol/LHS, refinamento adaptativo)
  • Ponderação da perda ou balanceamento adaptativo
  • Um otimizador de segunda etapa como L-BFGS

Problemas inversos (inverse problems): aprender parâmetros desconhecidos a partir de dados + física

PINNs lidam naturalmente com identificação de parâmetros (parameter identification): trate parâmetros físicos desconhecidos como variáveis treináveis (trainable variables) junto com os pesos da rede.

Exemplo: se (\alpha) na equação do calor é desconhecido, defina (\alpha=\texttt{torch.nn.Parameter}(\cdot)) e inclua-o no otimizador. O termo do resíduo da EDP conduz (\alpha) a valores consistentes tanto com a física quanto com os dados observados.

Casos de uso típicos:

  • Estimar campos de permeabilidade em escoamento no subsolo
  • Inferir parâmetros constitutivos em mecânica dos sólidos
  • Identificar taxas de reação em cinética química

Essa combinação de “física + dados esparsos” é um dos cenários mais atraentes para PINNs.

Aplicações comuns

Dinâmica de fluidos (Navier–Stokes e além)

  • Reconstrução de campos de velocidade/pressão a partir de sensores esparsos (por exemplo, cenários tipo PIV)
  • Assimilação de dados (data assimilation) e inferência de parâmetros (por exemplo, viscosidade)
  • Modelagem com modelos substitutos para escoamentos em geometrias complexas (frequentemente com decomposição de domínio)

Turbulência em alto número de Reynolds continua desafiadora para PINNs “vanilla”; amostragem, arquiteturas e hibridização especializadas frequentemente são necessárias.

Transferência de calor e difusão

  • Condução estacionária e transiente
  • Difusão anisotrópica em materiais
  • Identificação de parâmetros térmicos a partir de medições limitadas

Esses frequentemente são bons problemas “iniciais” de PINN porque a EDP é suave e bem comportada.

Mecânica dos sólidos

  • Elasticidade linear e campos de deslocamento/tensão
  • Identificação inversa do módulo de Young ou parâmetros de dano
  • Acoplamento multifísico (multi-physics coupling) (termoelasticidade)

Eletromagnetismo e ondas

  • Equações de Maxwell (domínio do tempo/frequência)
  • Propagação de ondas acústicas e elásticas
  • Espalhamento e problemas inversos de fontes

Problemas de ondas frequentemente exigem características de Fourier ou arquiteturas especializadas devido a soluções oscilatórias.

Geociências e clima

  • Escoamento de água subterrânea, transporte de contaminantes
  • Modelos reduzidos (reduced models) para inversão restrita por EDP (PDE-constrained inversion)
  • Assimilação de dados com restrições físicas

Modelagem biomédica

  • Fluxo sanguíneo (frequentemente em modelos simplificados)
  • Modelos de difusão e reação em tecidos
  • Estimativa de parâmetros fisiológicos sob restrições de EDP

Variantes e extensões de PINNs

PINNs têm muitas extensões para lidar com fraquezas conhecidas:

  • PINNs variacionais/em forma fraca (variational/weak-form PINNs): impõem a física via integrais contra funções teste (pode melhorar a robustez e reduzir requisitos de ordem das derivadas).
  • PINNs conservativas (conservative PINNs): projetam perdas/arquiteturas que preservam melhor leis de conservação (massa, momento, energia).
  • PINNs com decomposição de domínio (domain decomposition PINNs): treinam múltiplas PINNs em subdomínios com condições de interface (ajuda no escalonamento e no comportamento multiescala).
  • PINNs de multifidelidade (multi-fidelity PINNs): combinam simulações grosseiras com dados esparsos de alta fidelidade.
  • PINNs com quantificação de incerteza (uncertainty-aware PINNs): abordagens bayesianas ou de ensemble (ensemble approaches) para quantificar incerteza (útil quando os dados são ruidosos ou há incompatibilidade do modelo).

Essas abordagens frequentemente importam mais do que o tamanho bruto da rede.

Quando PINNs funcionam bem (e quando não funcionam)

Pontos fortes

  • Aproximação livre de malha (mesh-free) para domínios complexos
  • Forma natural de incorporar estrutura conhecida de EDP
  • Funciona com medições esparsas/ruidosas (a física atua como regularizador (regularizer))
  • Produz modelos substitutos diferenciáveis para otimização/controle a jusante

Limitações

  • O treinamento pode ser instável e sensível a hiperparâmetros (hyperparameters) (pesos, amostragem, escalonamento)
  • EDPs rígidas/multiescala podem derrotar formulações ingênuas
  • Derivadas de alta ordem podem ser caras e numericamente desafiadoras
  • Não há garantia de convergência comparável à de solucionadores clássicos sem um projeto cuidadoso

Uma regra prática: PINNs frequentemente são melhores como ferramentas híbridas—para problemas inversos, modelagem com modelos substitutos e assimilação de dados—do que como substituições imediatas (drop-in replacements) de solucionadores maduros de EDPs em todo regime.

Dicas práticas de ferramentas

  • Comece com formas bem escalonadas e adimensionais de EDP.
  • Normalize entradas/saídas; mantenha valores próximos de (\mathcal{O}(1)).
  • Use ativações suaves (tanh, softplus) e considere características de Fourier para soluções oscilatórias.
  • Monitore termos de perda separados (EDP vs. condições de contorno/condições iniciais vs. dados) e normas de gradiente para diagnosticar desbalanceamento.
  • Use amostragem adaptativa quando resíduos se localizarem.
  • Considere um otimizador em duas etapas (Adam e depois L-BFGS) para muitos problemas suaves.
  • Para problemas grandes, trate isso como Treinamento em Escala: fazer profiling dos custos de diferenciação automática, usar batching de pontos de colocalização e gerenciar memória se tornam críticos.

Resumo

Redes Neurais Informadas pela Física transformam a resolução de EDPs em um problema de otimização (optimization problem): uma rede neural aproxima a solução, enquanto a função de perda penaliza violações das equações governantes e das condições de contorno/iniciais (e, opcionalmente, ajusta dados medidos). A diferenciação automática torna viável computar as derivadas necessárias para os resíduos da EDP, enquanto escolhas cuidadosas sobre imposição de restrições, amostragem de colocalização, ponderação de perdas e otimização frequentemente determinam o sucesso.

PINNs são uma ponte poderosa entre computação científica (scientific computing) e aprendizado profundo (deep learning)—particularmente valiosa para problemas inversos e cenários em que a física é conhecida, mas os dados rotulados são limitados—porém exigem um projeto de treinamento cuidadoso para lidar com rigidez, fenômenos multiescala e restrições complexas.