Representações Neurais Implícitas

Visão geral

Representações neurais implícitas (implicit neural representations, INRs) representam um sinal (uma imagem, uma forma 3D, um campo de radiância, uma função de distância com sinal, etc.) como uma função contínua implementada por uma rede neural. Em vez de armazenar valores em uma grade discreta (pixels/voxels) ou em uma estrutura explícita (malha/nuvem de pontos), uma INR aprende um mapeamento:

[ f_\theta:\ \mathbf{x}\in \mathbb{R}^d \ \mapsto\ \mathbf{y}\in \mathbb{R}^k ]

  • Entrada (\mathbf{x}): coordenadas (por exemplo, ((u,v)) em 2D, ((x,y,z)) em 3D, além de tempo (t), direção de visualização (\mathbf{d}), etc.)
  • Saída (\mathbf{y}): valor do sinal (por exemplo, cor RGB, densidade, ocupação/probabilidade de ocupação, valor de SDF, rótulo semântico)

Os parâmetros da rede (\theta) são a representação. Para recuperar valores, você consulta a função nas coordenadas desejadas. Isso torna as INRs naturalmente adequadas para:

  • Reamostragem contínua (super-resolução, pontos de vista arbitrários)
  • Diferenciação em relação às coordenadas (normais a partir de gradientes de SDF)
  • Renderização neural / campos de radiância (modelos no estilo NeRF)
  • Compressão (armazenar uma rede compacta em vez de todas as amostras)

As INRs são uma técnica fundamental dentro de Renderização Neural e frequentemente interagem com Renderização Diferenciável, Funções de Distância com Sinal (SDFs) e pipelines de reconstrução 3D envolvendo Calibração de Câmera, Estimativa de Pose e Ajuste de Feixe.

Por que “implícitas”?

Representações tradicionais são explícitas:

  • Imagem: um tensor (H\times W \times 3) de pixels
  • Volume: uma grade de voxels 3D
  • Forma: uma malha (vértices + faces)
  • Nuvem de pontos: um conjunto de amostras discretas

Uma INR é implícita porque não enumera todos os valores. Em vez disso, ela define o sinal implicitamente como uma função. Você pode avaliá-la em qualquer ponto do domínio — muitas vezes em resoluções ou coordenadas não vistas durante o treinamento.

MLPs baseadas em coordenadas: a ideia central das INRs

A INR canônica é uma MLP baseada em coordenadas (coordinate-based MLP) (perceptron multicamadas) (veja Redes Neurais, Perceptrons Multicamadas):

  • Entradas: coordenadas (\mathbf{x})
  • Várias camadas totalmente conectadas com não linearidades
  • Saída: valor do sinal (\mathbf{y})

Exemplo: uma imagem como uma função

Uma imagem pode ser modelada como:

[ f_\theta(u,v) = (r,g,b) ]

onde ((u,v)\in[-1,1]^2) são coordenadas de pixel normalizadas, e a saída é RGB em ([0,1]^3). O treinamento amostra pixels aleatórios e faz regressão de suas cores.

Benefícios

  • Contínua: consultar em qualquer ((u,v)) → super-resolução natural
  • Compacta: os pesos da rede podem ser menores do que a imagem bruta
  • Suavidade pode ser aprendida/regularizada

Desafio: viés espectral (spectral bias) MLPs padrão tendem a aprender primeiro componentes de baixa frequência e têm dificuldade com detalhes de alta frequência (texturas finas, bordas nítidas). Isso é frequentemente chamado de viés espectral.

Codificações posicionais / de Fourier (e por que elas importam)

Um grande avanço prático para INRs é transformar as coordenadas antes de alimentá-las na MLP. A abordagem mais comum é um mapeamento de características senoidais / de Fourier:

[ \gamma(\mathbf{x}) = \left[\sin(2\pi \mathbf{B}\mathbf{x}),\ \cos(2\pi \mathbf{B}\mathbf{x})\right] ]

  • (\mathbf{B}) pode ser um conjunto fixo de frequências aleatórias (características de Fourier), um conjunto estruturado de frequências (codificação posicional) ou até mesmo aprendido.
  • Alimentar (\gamma(\mathbf{x})) na MLP torna muito mais fácil representar variações de alta frequência.

Esta é a mesma ideia básica por trás da codificação posicional do NeRF: a própria MLP permanece relativamente pequena, mas as características de entrada contêm informação de frequência em múltiplas escalas.

Dicas práticas para codificações posicionais

  • Normalize as coordenadas para um intervalo limitado (comumente ([-1,1]) ou ([0,1])).
  • Escolha bandas de frequência com base no nível de detalhe esperado:
    • Poucas frequências → suavização excessiva
    • Muitas frequências → otimização mais difícil, artefatos tipo aliasing, sobreajuste (veja Sobreajuste)
  • Muitos pipelines no estilo NeRF usam codificação do grosso para o fino / progressiva (coarse-to-fine / progressive encoding) (habilitar frequências mais altas depois) para estabilizar o treinamento.

Além da “MLP vanilla”: variantes comuns de design de INRs

As INRs são mais um padrão do que uma única arquitetura. Variantes comuns incluem:

Ativações senoidais (estilo SIREN)

Em vez de codificar a entrada, use ativações periódicas por toda a rede:

[ \phi(z) = \sin(\omega_0 z) ]

Isso pode representar bem sinais de alta frequência, mas requer inicialização cuidadosa e ajuste de (\omega_0).

INRs condicionais (uma rede para muitos sinais)

Em vez de treinar uma rede por sinal, você pode condicionar em um código latente (\mathbf{z}):

[ f_\theta(\mathbf{x}, \mathbf{z}) \mapsto \mathbf{y} ]

  • (\mathbf{z}) pode vir de um codificador (Autoencoders) ou ser otimizado por instância.
  • Usado para famílias de formas, cenas dinâmicas ou geração condicionada por classe.

Codificações híbridas (grades + MLP)

Campos de radiância modernos em tempo real frequentemente usam características de grade multi-resolução (incluindo codificações de grade hash) combinadas com uma pequena MLP. A grade armazena características aprendíveis no espaço; a MLP as decodifica em saídas. Isso pode ser dramaticamente mais rápido do que uma INR puramente baseada em MLP, mantendo a continuidade via interpolação.

Como as INRs são treinadas

A maioria das INRs é treinada amostrando coordenadas e minimizando uma perda de reconstrução via Retropropagação e Descida do Gradiente.

Objetivo genérico de regressão supervisionada

Dadas amostras ({(\mathbf{x}_i, \mathbf{y}_i)}):

[ \min_\theta \sum_i \mathcal{L}(f_\theta(\mathbf{x}_i), \mathbf{y}_i) ]

Perdas comuns:

  • L2 / MSE para valores contínuos (RGB, SDF)
  • L1 para robustez/nitidez em imagens
  • Entropia cruzada binária para ocupação
  • Perdas perceptuais (espaço de características) para melhor realismo de textura

A estratégia de amostragem importa

  • Para imagens: pixels aleatórios uniformes ou amostragem por importância (por exemplo, bordas)
  • Para campos 3D: amostrar mais frequentemente perto de superfícies (amostragem focada na superfície)
  • Para NeRF: amostrar pontos ao longo de raios (do grosso para o fino / reamostragem por importância)

Regularização para campos geométricos

Em 3D, frequentemente você adiciona priors para estabilizar ou impor consistência geométrica:

  • Perda eikonal (Eikonal loss) para SDFs: [ |\nabla f_\theta(\mathbf{x})| \approx 1 ]
  • Penalidades de suavidade / variação total em características de grade
  • Penalidades de esparsidade (incentivando espaço vazio)

Isso se conecta de perto a Funções de Distância com Sinal (SDFs) e reconstrução de superfícies.

Exemplo prático: ajustando uma INR a uma imagem (estilo PyTorch)

Este exemplo treina uma INR para representar uma única imagem RGB. Ele usa características de Fourier para reduzir o viés espectral.

import torch
import torch.nn as nn
import torch.nn.functional as F

class FourierFeatures(nn.Module):
    def __init__(self, in_dim=2, num_frequencies=10, scale=10.0):
        super().__init__()
        B = torch.randn(num_frequencies, in_dim) * scale
        self.register_buffer("B", B)

    def forward(self, x):  # x: [N, 2]
        # [N, F]
        proj = 2 * torch.pi * (x @ self.B.t())
        return torch.cat([torch.sin(proj), torch.cos(proj)], dim=-1)

class INR(nn.Module):
    def __init__(self, hidden=256, depth=4, ff_freq=10):
        super().__init__()
        self.ff = FourierFeatures(2, ff_freq)
        in_dim = 2 * ff_freq * 2  # sin+cos -> 2 * num_frequencies
        layers = []
        d = in_dim
        for _ in range(depth):
            layers += [nn.Linear(d, hidden), nn.ReLU(inplace=True)]
            d = hidden
        layers += [nn.Linear(hidden, 3)]
        self.net = nn.Sequential(*layers)

    def forward(self, xy):
        h = self.ff(xy)
        rgb = torch.sigmoid(self.net(h))  # constrain to [0,1]
        return rgb

# Training sketch
# coords: [H*W, 2] in [-1, 1]
# target: [H*W, 3] in [0, 1]
model = INR().cuda()
opt = torch.optim.Adam(model.parameters(), lr=1e-3)

for step in range(2000):
    idx = torch.randint(0, coords.shape[0], (8192,), device="cuda")
    pred = model(coords[idx])
    loss = F.mse_loss(pred, target[idx])
    opt.zero_grad()
    loss.backward()
    opt.step()

Como usar para super-resolução: após o treinamento, gere uma grade de coordenadas ((u,v)) com resolução mais alta e consulte model(xy) — sem necessidade de retreinamento.

INRs em visão 3D: ocupação, SDFs e campos de radiância

As INRs se destacam em 3D porque “campos contínuos sobre (\mathbb{R}^3)” são um encaixe natural.

Campos de ocupação

Modelam um campo binário indicando se um ponto está dentro de uma forma:

[ f_\theta(\mathbf{x}) \approx P(\text{ocupado} \mid \mathbf{x}) ]

Extraia uma superfície escolhendo um isovalor (por exemplo, 0.5) e executando marching cubes.

Funções de distância com sinal (SDFs)

Modelam uma distância com sinal contínua:

[ f_\theta(\mathbf{x}) = \text{SDF}(\mathbf{x}) ]

A superfície é o conjunto de nível zero (f_\theta(\mathbf{x})=0). As normais vêm de gradientes:

[ \mathbf{n}(\mathbf{x}) = \frac{\nabla f_\theta(\mathbf{x})}{|\nabla f_\theta(\mathbf{x})|} ]

Essa integração estreita entre representação + derivadas é um dos motivos pelos quais INRs de SDF são amplamente usadas (veja Funções de Distância com Sinal (SDFs)).

INRs para renderização neural: campos de radiância no estilo NeRF

Uma aplicação definidora das INRs são modelos no estilo Campos de Radiância Neurais (Neural Radiance Fields, NeRF), que representam uma cena como um campo contínuo consultado ao longo de raios da câmera (veja Renderização Neural, Renderização Diferenciável).

O que a INR do NeRF prevê

O NeRF clássico parametriza:

  • Densidade (\sigma(\mathbf{x}) \ge 0) (quanto de matéria há no ponto 3D (\mathbf{x}))
  • Cor (\mathbf{c}(\mathbf{x}, \mathbf{d}) \in [0,1]^3) (aparência dependente da direção de visualização)

Assim, a rede aproxima:

[ f_\theta(\mathbf{x}, \mathbf{d}) \mapsto (\sigma, \mathbf{c}) ]

onde (\mathbf{d}) é a direção de visualização (vetor unitário).

Renderização como integração diferenciável ao longo de raios

Para cada pixel, lance um raio (\mathbf{r}(t) = \mathbf{o} + t\mathbf{d}) e amostre pontos ao longo dele. A cor do pixel é uma integral de renderização volumétrica discretizada como:

[ \hat{\mathbf{C}} = \sum_i T_i \alpha_i \mathbf{c}_i ]

  • (\alpha_i) depende da densidade (\sigma_i) e do tamanho do passo
  • (T_i) é a transmitância acumulada (quanto de luz chega à câmera)

O treinamento minimiza a perda fotométrica entre pixels renderizados e imagens observadas, atualizando (\theta) por meio de renderização diferenciável.

Dependências práticas: câmeras e otimização

Pipelines de NeRF dependem fortemente de:

Compressão e super-resolução baseadas em INRs

Como uma INR é uma função paramétrica compacta, ela pode atuar como um esquema de compressão: armazenar os pesos da rede (e possivelmente uma grade de codificação) em vez de todas as amostras.

Compressão neural (fluxo de trabalho conceitual)

  1. Ajuste uma INR a um sinal específico (imagem, vídeo, forma).
  2. Quantize/pode os parâmetros da rede.
  3. Armazene os parâmetros comprimidos.
  4. Decodifique avaliando a rede nas coordenadas desejadas.

Onde ajuda

  • Quando os sinais são estruturados e compressíveis por uma função
  • Quando o acesso aleatório a resolução arbitrária é valioso

Trade-offs

  • A decodificação requer inferência neural (mais lenta do que codecs simples de imagem, a menos que seja otimizada)
  • A qualidade depende da arquitetura e do bitrate (número de parâmetros / quantização)

Super-resolução

A super-resolução com INR é direta:

  • Treine em amostras de baixa resolução (possivelmente com considerações de anti-aliasing).
  • Consulte uma grade de coordenadas mais densa na inferência.

Isso funciona bem para sinais suaves e pode produzir resultados nítidos com codificações apropriadas, mas não recupera magicamente informação ausente nas medições — os priors vêm da classe de funções e do setup de treinamento.

INR vs representações 3D explícitas (e por que ambas existem)

INRs competem e se combinam com representações explícitas:

  • Malhas: renderização eficiente, superfícies explícitas, mas lidar com topologia é difícil.
  • Grades de voxels: simples, mas a memória escala mal com a resolução.
  • Nuvens de pontos: flexíveis, mas renderização e extração de superfície podem ser desafiadoras.
  • Grades de campos de radiância / Gaussianas: primitivos explícitos podem ser mais rápidos para renderizar.

Uma alternativa explícita recente importante para renderização em tempo real é Splatting Gaussiano 3D (3D Gaussian Splatting), que usa primitivos gaussianos 3D explícitos em vez de um campo contínuo definido por MLP. Na prática:

  • INRs (tipo NeRF) frequentemente oferecem alta qualidade e flexibilidade.
  • Splatting gaussiano frequentemente oferece velocidade superior de treinamento/renderização.
  • Abordagens híbridas são comuns (características explícitas + decodificação implícita).

Orientação prática: fazendo INRs funcionarem bem

Escolhas de coordenadas e normalização

  • Normalize entradas (por exemplo, ([-1,1])) para treinamento estável.
  • Use referenciais de coordenadas significativos (coordenadas do mundo para cenas; coordenadas do objeto para formas).
  • Para cenas dinâmicas, adicione tempo (t) como entrada (mas cuidado com emaranhamento e complexidade do movimento).

Padrões arquiteturais que frequentemente funcionam

  • Use codificações posicionais/de Fourier para sinais de alta frequência.
  • Prefira conexões de atalho (skip connections) para MLPs profundas (ajuda a otimização).
  • Para campos de radiância, é comum separar “ramo de densidade” e “ramo de cor”.

Regularização e priors

  • Tarefas geométricas frequentemente precisam de priors explícitos (eikonal, esparsidade).
  • Tarefas de imagem podem se beneficiar de perdas L1/perceptuais em vez de MSE puro.

Considerações de desempenho

  • INRs puramente baseadas em MLP podem ser lentas para renderização em grande escala (muitas consultas).
  • Acelerações incluem:
    • Codificações de grade/hash multi-resolução + decodificadores MLP minúsculos
    • Destilação para modelos menores
    • “Assar” (baking) as saídas em estruturas explícitas para renderização rápida

Limitações e problemas em aberto

  • Velocidade e escalabilidade: muitas aplicações exigem milhões a bilhões de consultas.
  • Aliasing e teoria de amostragem: consultar campos de alta frequência sem amostragem adequada pode produzir artefatos; o treinamento pode “trapacear” escondendo altas frequências.
  • Generalização: INRs por cena (como o NeRF clássico) ajustam bem uma cena, mas não generalizam sem condicionamento ou treinamento em larga escala.
  • Editabilidade: representações explícitas costumam ser mais fáceis de manipular (por exemplo, editar uma malha).
  • Incerteza e ambiguidade: problemas inversos (poucas vistas, medições ruidosas) se beneficiam de modelagem probabilística além de INRs determinísticas padrão.

Resumo

Representações neurais implícitas modelam sinais como funções neurais contínuas consultadas em coordenadas. A receita básica — MLPs baseadas em coordenadas mais codificações posicionais/de Fourier — possibilitou representações de alta qualidade de imagens e cenas 3D, especialmente em renderização neural (campos de radiância no estilo NeRF). INRs também são úteis para compressão (armazenar pesos) e super-resolução (consultar em resolução maior) e se integram naturalmente à geometria 3D por meio de campos de ocupação e SDF.

No ecossistema mais amplo de visão 3D, INRs complementam abordagens explícitas como malhas e Splatting Gaussiano 3D e se conectam fortemente a fluxos de trabalho de modelagem de câmera e otimização, como Calibração de Câmera e Ajuste de Feixe.