Programação Diferenciável

O que é programação diferenciável?

Programação diferenciável (differentiable programming) é a prática de projetar componentes de software — funções, módulos, algoritmos e, às vezes, programas inteiros — de modo que sejam diferenciáveis (ou “quase em toda parte” diferenciáveis (almost everywhere differentiable)) e possam ser otimizados de ponta a ponta com métodos baseados em gradiente (gradient-based methods) usando Diferenciação Automática (Autodiff).

No software convencional, você escreve manualmente regras (“se isso, faça aquilo”) e ajusta parâmetros manualmente. Na programação diferenciável, você ainda escreve estrutura e lógica, mas expõe parâmetros treináveis (trainable parameters) e uma função de perda (loss function) e, então, deixa a otimização baseada em gradiente (por exemplo, Descida do Gradiente (Gradient Descent) com Otimizadores (Optimizers) modernos) ajustar esses parâmetros automaticamente.

Esse ponto de vista generaliza o aprendizado profundo (deep learning) padrão:

• Uma rede neural (neural network) é um programa diferenciável: uma composição de operações diferenciáveis.
• A programação diferenciável expande a caixa de ferramentas para incluir fluxo de controle (control flow) (laços/condicionais), estruturas de dados (data structures), solvers numéricos (numerical solvers) e algoritmos de domínio (domain algorithms) — desde que gradientes possam ser propagados através deles.

A ideia matemática central

Um programa diferenciável define uma função

[ y = f(x; \theta) ]

onde:

• (x) são as entradas (dados, estado, observações),
• (\theta) são os parâmetros que você quer aprender,
• (y) é a saída (previsão, ação, trajetória simulada etc.).

Você também define uma perda:

[ \mathcal{L}(\theta) = \ell(f(x; \theta), \text{target}) ]

Treinar significa calcular (\nabla_\theta \mathcal{L}) e atualizar (\theta) com um otimizador (optimizer).

Por que gradientes importam

Gradientes são poderosos porque fornecem informação direcional: como alterar parâmetros para reduzir a perda. Isso torna a otimização muito mais eficiente do que uma busca caixa-preta (black-box) em alta dimensionalidade, especialmente quando (f) é grande.

O gradiente é calculado pela regra da cadeia (chain rule), operacionalizada pela Retropropagação (Backpropagation) e implementada pela diferenciação automática, tipicamente em modo reverso (reverse mode) para aprendizado profundo (eficiente quando há muitos parâmetros e uma perda escalar).

Diferenciação automática na prática: grafos de computação e estrutura do programa

A maioria dos frameworks de aprendizado de máquina (machine learning, ML) (PyTorch, JAX, TensorFlow) representa um programa como um grafo de computação (computation graph) — explicitamente ou implicitamente — e o diferencia automaticamente.

Principais consequências para a programação diferenciável:

• Toda operação deve ter uma derivada definida (ou um substituto).
• Valores intermediários geralmente são salvos para o passo de retropropagação (trade-off de memória).
• Fluxo de controle e estruturas de dados precisam ser tratados com cuidado para que os gradientes sejam significativos e estáveis.

Exemplo: “código comum” pode ser diferenciável

Aqui vai um exemplo simples em PyTorch em que o “modelo” não é uma pilha padrão de camadas de rede neural, mas um pequeno programa com laços e aritmética:

import torch

def simulate(x0, theta, steps=50):
    # A toy dynamical system: x_{t+1} = x_t + theta * sin(x_t)
    x = x0
    for _ in range(steps):
        x = x + theta * torch.sin(x)
    return x

theta = torch.tensor(0.1, requires_grad=True)
x0 = torch.tensor(1.0)
target = torch.tensor(2.0)

y = simulate(x0, theta)
loss = (y - target).pow(2)

loss.backward()
print("loss:", loss.item())
print("d(loss)/d(theta):", theta.grad.item())

Isso ilustra a promessa central: você pode escrever um processo algorítmico, e desde que ele seja diferenciável, o framework calculará gradientes através dele.

Diferenciando através de fluxo de controle

Fluxo de controle é onde a programação diferenciável começa a parecer “programação”, e não apenas “empilhar camadas”.

Laços

Laços geralmente funcionam bem quando:

• o corpo do laço é diferenciável, e
• o número de iterações é fixo (ou ao menos bem definido para cada execução).

No entanto, laços trazem preocupações práticas:

• Memória: a diferenciação automática em modo reverso pode precisar armazenar valores intermediários de cada iteração.
• Estabilidade: a aplicação repetida pode criar gradientes que desaparecem/explodem (ver Problemas de Gradiente (Gradient Issues)).

Mitigações incluem:

• pontos de verificação (checkpointing) / rematerialização (rematerialization) (recomputar alguns intermediários em vez de armazená-los),
• parametrizações estáveis e normalização (relacionadas a Inicialização & Normalização (Initialization & Normalization)),
• clipping de gradiente (gradient clipping),
• diferenciação implícita (implicit differentiation) (coberta abaixo).

Condicionais e ramificações

Condicionais são mais complicados.

• Se a condição do ramo depende dos dados, mas é diferenciável (por exemplo, if x > 0), então o programa torna-se não diferenciável na fronteira e tem gradiente zero quase em toda parte em relação à condição quando implementado como um booleano rígido.
• Se a condição do ramo depende de parâmetros que você quer aprender, os gradientes podem não fluir de forma útil.

Estratégias comuns:

1. Relaxamentos suaves (smooth relaxations): substituir decisões rígidas por misturas suaves.
2. Gradientes substitutos / straight-through (surrogate/straight-through gradients): usar uma operação discreta no passo forward, mas injetar um gradiente aproximado no passo backward.
3. Truques de reparametrização (reparameterization tricks) para decisões estocásticas.

Padrão prático: condicional suave (mistura de ramos)

Em vez de:

if gate > 0:
    y = a(x)
else:
    y = b(x)

Use um gate suave: [ y = \sigma(g) \cdot a(x) + (1-\sigma(g)) \cdot b(x) ]

Isso mantém tudo diferenciável e permite que o aprendizado ajuste o gate de forma contínua.

Estruturas de dados diferenciáveis e algoritmos “suaves”

Estruturas de dados clássicas (pilhas, filas, mapas hash) e algoritmos (argmax, ordenação, programação dinâmica) frequentemente envolvem escolhas discretas, que não são diferenciáveis.

A programação diferenciável frequentemente substitui essas escolhas por aproximações contínuas:

• Atenção softmax (softmax attention) como alternativa diferenciável à indexação rígida.
• Ordenação suave (soft sorting) / ranqueamento diferenciável (differentiable ranking) (por exemplo, normalização de Sinkhorn (Sinkhorn normalization), matrizes de permutação suaves).
• Pilhas/filas diferenciáveis (differentiable stacks/queues), em que push/pop tornam-se operações ponderadas.
• Relaxações top‑k (top‑k relaxations) usando proxies contínuos.

Exemplo: substituindo `argmax` por softmax

Seleção rígida: [ i = \arg\max_j s_j ] não é diferenciável.

Seleção suave: [ w = \text{softmax}(s/\tau) ] e usar uma soma ponderada: [ y = \sum_j w_j , v_j ]

À medida que a temperatura (\tau \to 0), isso aproxima argmax, mas os gradientes ficam mais “afiados” e podem se tornar instáveis — então (\tau) frequentemente é reduzida (annealed) com cuidado.

Essas substituições “suaves” são fundamentais em muitos sistemas que se parecem com interpretadores diferenciáveis (differentiable interpreters), redes com memória aumentada (memory-augmented networks) e modelos neuro-simbólicos (neuro-symbolic models).

Diferenciando através de solvers: desenrolamento vs diferenciação implícita

Muitos componentes valiosos não são um cálculo simples feed-forward (feed-forward); eles são o resultado de um solver iterativo (iterative solver):

• otimização (mínimos quadrados (least squares), programação quadrática (quadratic programming, QP)),
• busca de raízes (root finding),
• cálculo de equilíbrio (equilibrium computation),
• passos de tempo em simulação física (physics simulation time stepping),
• recorrências de programação dinâmica (dynamic programming recurrences).

Há duas formas principais de diferenciar através desses componentes.

1) Desenrolamento (unrolling) (diferenciar através das iterações)

Você executa o solver por (T) passos e faz retropropagação por todos os passos.

Prós:

• simples de implementar,
• funciona com diferenciação automática padrão.

Contras:

• caro em memória/tempo,
• gradientes podem ser instáveis para (T) grande,
• o custo do passo backward escala com o número de iterações.

2) Diferenciação implícita (implicit differentiation) (diferenciar a solução)

Se a saída do solver (z^*) é definida implicitamente por uma equação como: [ F(z^*, \theta) = 0 ] então, sob condições de regularidade, o Teorema da Função Implícita (Implicit Function Theorem) fornece: [ \frac{d z^*}{d\theta} = - \left(\frac{\partial F}{\partial z}\right)^{-1} \frac{\partial F}{\partial \theta} ]

Isso evita retropropagar por cada iteração e pode ser muito mais eficiente/estável.

Essa abordagem aparece em:

• camadas de otimização convexa diferenciáveis (differentiable convex optimization layers),
• modelos de equilíbrio (equilibrium models) (por exemplo, redes de equilíbrio profundo (deep equilibrium networks)),
• física diferenciável com restrições.

Na prática, você raramente inverte matrizes explicitamente; você resolve sistemas lineares (geralmente com métodos iterativos) e pode definir passos backward customizados.

Simuladores diferenciáveis: física, gráficos e dinâmica

Um grande impulsionador da programação diferenciável é a capacidade de aprender através de simuladores em vez de aprender tudo do zero.

Física diferenciável e EDOs (ODEs)

Se um simulador evolui um estado (x(t)) de acordo com a dinâmica: [ \dot{x} = f(x, t; \theta) ] então você pode otimizar (\theta) (parâmetros físicos, parâmetros de controle, condições iniciais) ao fazer correspondência com trajetórias observadas.

Dois métodos comuns de gradiente:

• Retropropagação através do integrador (integrator) (desenrolar passos de tempo).
• Métodos de sensibilidade adjunta (adjoint sensitivity methods) (uma abordagem ao estilo implícito para EDOs que pode reduzir o uso de memória).

Isso sustenta estimação de parâmetros, problemas inversos e aprendizado de máquina científico (scientific ML) (frequentemente discutido junto de Redes Neurais Informadas pela Física (Physics-Informed Neural Networks), embora programação diferenciável seja mais ampla do que PINNs).

Renderização diferenciável e gráficos

Pipelines de renderização (rendering) incluem muitas etapas não diferenciáveis (visibilidade, rasterização). A programação diferenciável introduz:

• rasterizadores diferenciáveis (differentiable rasterizers) (gradientes aproximados),
• visibilidade suave (soft visibility),
• estimadores de Monte Carlo (Monte Carlo estimators) com estimadores de gradiente.

Aplicações incluem gráficos inversos (inverse graphics), reconstrução 3D (3D reconstruction) e aprendizado de parâmetros de cena (scene parameters) a partir de imagens.

Robótica e controle

Em robótica, você frequentemente se importa com:

• identificação de sistemas (system identification): aprender parâmetros de dinâmica a partir de dados,
• otimização de trajetórias (trajectory optimization): otimizar uma sequência de controle através de dinâmicas diferenciáveis,
• controle preditivo por modelo (model predictive control, MPC): resolver um problema de otimização repetidamente em um loop.

A programação diferenciável permite treinamento de ponta a ponta (end-to-end training) de pipelines de percepção + planejamento + controle, e dá suporte ao aprendizado de componentes dentro de loops de controle.

Relação com redes neurais

Programação diferenciável é melhor vista como um superconjunto (superset) do aprendizado profundo padrão.

• Um modelo típico de Redes Neurais (Neural Networks) é uma composição diferenciável de operações de álgebra linear e não linearidades.
• A programação diferenciável diz: você pode incorporar mais estrutura do que “camadas”, incluindo algoritmos, solvers e restrições de domínio — e ainda assim treinar com retropropagação.

Isso frequentemente leva a modelos híbridos (hybrid models):

• componentes neurais lidam com percepção ou resíduos desconhecidos,
• componentes algorítmicos impõem estrutura conhecida (por exemplo, leis de conservação, restrições geométricas, relações lógicas).

Nesse sentido, a programação diferenciável é um habilitador-chave de aprendizado estruturado, informado pelo domínio (structured, domain-informed learning).

Lógica diferenciável e conexões neuro-simbólicas

O raciocínio simbólico clássico usa operações discretas:

• lógica booleana,
• unificação,
• busca,
• disparo de regras.

Em geral, isso não é diferenciável. A programação diferenciável permite variantes relaxadas (relaxed) ou probabilísticas (probabilistic):

• Lógica fuzzy (fuzzy logic): substituir AND/OR por t-norms e t-conorms contínuos.
• Satisfação suave (soft satisfaction) de restrições: penalizar violações de restrições com perdas diferenciáveis.
• Prova de teoremas neural (neural theorem proving) / unificação diferenciável (differentiable unification): usar escores de similaridade em vez de correspondências exatas.
• Indução de programas com gradientes (program induction with gradients): aprender parâmetros de interpretadores diferenciáveis ou módulos neurais.

Por que isso importa:

• Sistemas simbólicos são eficientes em dados e interpretáveis, mas frágeis.
• Sistemas neurais são flexíveis, mas podem ignorar estrutura.
• A programação diferenciável pode combiná-los, formando uma base prática para IA Neuro-Simbólica (Neuro-Symbolic AI).

Por que programação diferenciável é útil

Otimização de ponta a ponta entre componentes

Em vez de ajustar cada módulo separadamente (percepção, mapeamento, planejamento), você pode treinar o pipeline inteiro para minimizar o objetivo real.

Isso reduz a “cola” feita à mão (hand-engineered glue) e frequentemente melhora o desempenho quando componentes interagem de maneiras complexas.

Incorporando vieses indutivos e restrições

Estrutura escrita manualmente pode codificar:

• invariâncias,
• leis de conservação,
• monotonicidade,
• restrições geométricas,
• etapas algorítmicas conhecidas.

Isso pode melhorar a generalização e reduzir a complexidade amostral (sample complexity) em comparação com modelos puramente caixa-preta.

Melhor estimação de parâmetros e problemas inversos

Em ciência/engenharia você frequentemente quer:

• parâmetros que expliquem dados (não apenas previsões),
• extensões cientes de incerteza (uncertainty-aware) (frequentemente combinadas com métodos probabilísticos),
• modelos fisicamente significativos.

Simuladores diferenciáveis tornam isso natural: definir uma perda de discrepância e otimizar parâmetros do simulador.

Aprendizado mais rápido via informação de gradiente

Em comparação com busca sem gradiente, o aprendizado baseado em gradiente costuma ser muito mais eficiente em espaços de parâmetros de alta dimensionalidade — um dos motivos pelos quais o aprendizado profundo funciona em escala.

Aplicações práticas

Aprendizado de máquina científico e de engenharia

• aprender modelos constitutivos em ciência de materiais (híbrido física + resíduos neurais),
• calibrar modelos de EDP/EDO a medições,
• assimilação de dados e identificação de sistemas,
• aprender modelos substitutos (surrogate models) em que gradientes permaneçam significativos para otimização.

Robótica

• cinemática/dinâmica diferenciáveis para calibração,
• aprender funções de custo a partir de demonstrações,
• otimização diferenciável de trajetórias,
• treinamento de ponta a ponta de políticas visuomotoras com física diferenciável (quando viável).

Modelagem probabilística e inferência

• verossimilhanças diferenciáveis (differentiable likelihoods) permitindo inferência baseada em gradiente,
• inferência variacional (variational inference) e gradientes de reparametrização (reparameterization gradients) (frequentemente ligados a Redes Neurais Bayesianas (Bayesian Neural Networks) e programação probabilística (probabilistic programming) moderna).

Pesquisa operacional diferenciável

• integrar camadas de otimização (optimization layers) (por exemplo, solvers de QP) dentro de redes neurais,
• aprender pesos de objetivo ou restrições a partir de dados enquanto preserva a estrutura de viabilidade (feasibility) .

Exemplo trabalhado: aprendendo um parâmetro físico por meio de um simulador diferenciável

Abaixo há um exemplo compacto: estimar uma constante de mola (k) a partir de movimento observado usando um integrador de Euler diferenciável simples. (Isso é intencionalmente mínimo; sistemas reais podem usar integradores melhores.)

import torch

def simulate_mass_spring(x0, v0, k, m=1.0, dt=0.01, steps=200):
    # x'' = -(k/m) x
    x = x0
    v = v0
    xs = []
    for _ in range(steps):
        a = -(k/m) * x
        v = v + dt * a
        x = x + dt * v
        xs.append(x)
    return torch.stack(xs)

# "Observed" trajectory generated with true k (in practice, from sensors)
true_k = 4.0
x0, v0 = torch.tensor(1.0), torch.tensor(0.0)
with torch.no_grad():
    obs = simulate_mass_spring(x0, v0, torch.tensor(true_k)) + 0.01 * torch.randn(200)

# Learn k by minimizing trajectory error
k = torch.tensor(1.0, requires_grad=True)
opt = torch.optim.Adam([k], lr=0.1)

for step in range(200):
    pred = simulate_mass_spring(x0, v0, k)
    loss = torch.mean((pred - obs)**2)

    opt.zero_grad()
    loss.backward()
    opt.step()

print("estimated k:", k.item(), "true k:", true_k)

O que está acontecendo:

• O simulador é um programa com um laço (passos de tempo).
• A diferenciação automática calcula (\frac{d,\text{loss}}{dk}) através de todos os passos.
• Um otimizador atualiza (k) para corresponder à trajetória observada.

Esse padrão escala para simuladores muito mais ricos (corpo rígido (rigid body), fluidos (fluids), renderização diferenciável), embora estabilidade numérica e desempenho se tornem preocupações centrais.

Considerações de engenharia e armadilhas

Operações não diferenciáveis e “truques de gradiente (gradient hacks)”

Pontos comuns não diferenciáveis:

• comparações rígidas (>, <),
• indexação com escolhas discretas,
• arredondamento, casting para int,
• argmax, ordenação, operações com conjuntos.

Opções:

• relaxamentos suaves (softmax, ordenação suave),
• gradientes substitutos (estimadores straight-through (straight-through estimators)),
• estimadores probabilísticos (estimadores no estilo REINFORCE (REINFORCE-style estimators), maior variância).

Cada escolha afeta viés/variância (bias/variance), estabilidade e interpretabilidade.

Estabilidade numérica e patologias de gradiente

Programas profundos ou iterativos podem sofrer com gradientes que desaparecem/explodem; ver Problemas de Gradiente. Mitigações comuns:

• normalização e parametrização cuidadosa (ver Inicialização & Normalização),
• integradores estáveis para simulação,
• clipping de gradiente,
• usar diferenciação implícita em vez de desenrolamento.

Desempenho e memória

A diferenciação automática em modo reverso pode consumir muita memória porque armazena intermediários. Ferramentas incluem:

• pontos de verificação / rematerialização,
• passos backward customizados,
• adjoints específicos de solver (métodos adjuntos para EDO),
• vetorização e compilação (vectorization and compilation) (por exemplo, JAX jit) para tornar programas estruturados rápidos.

Depuração de gradientes

Verificações práticas:

• checar se a perda diminui em um problema pequeno,
• verificar se os gradientes são não nulos onde esperado,
• verificações de gradiente por diferenças finitas (finite-difference gradient checks) em entradas pequenas,
• observar NaNs/Infs (frequentemente vindos de simulação instável ou temperaturas de softmax extremas).

Como isso se encaixa em “fundamentos de aprendizado profundo”

Dentro de um currículo de aprendizado profundo, programação diferenciável se conecta diretamente a:

• Diferenciação Automática: o mecanismo que permite gradientes através de programas,
• Retropropagação: regra da cadeia sobre grafos de computação,
• Otimizadores: como parâmetros são atualizados,
• Regularização (Regularization): controlar overfitting mesmo quando o “modelo” é um pipeline algorítmico,
• Problemas de Gradiente: estabilidade em computação profunda/iterativa.

A principal mudança mental é: o “modelo” não precisa se parecer com uma rede neural. Ele pode ser um simulador, um planejador, um solver ou um sistema híbrido — desde que os gradientes possam fluir.

Resumo

Programação diferenciável é uma abordagem para construir sistemas de aprendizado de máquina em que os próprios programas — incluindo laços, condicionais (frequentemente relaxados), mecanismos do tipo estrutura de dados e solvers numéricos — são projetados para serem compatíveis com otimização baseada em gradiente via diferenciação automática.

Isso importa porque permite:

• treinamento de ponta a ponta entre componentes heterogêneos,
• integração fundamentada de conhecimento de domínio (física, geometria, restrições),
• sistemas neuro-simbólicos e científico/robóticos que combinam estrutura com capacidade de aprendizado.

À medida que sistemas de aprendizado de máquina misturam cada vez mais percepção, raciocínio e simulação, a programação diferenciável fornece um arcabouço unificador: escreva software estruturado, defina uma perda e deixe os gradientes fazerem o ajuste.

---