Autoencoder

Um autoencoder é uma rede neural treinada para reproduzir a própria entrada. Um codificador mapeia a entrada para um código compacto, muitas vezes chamado de representação latente; um decodificador mapeia o código de volta para uma reconstrução, e o treinamento minimiza a diferença entre a entrada e a reconstrução. Como o alvo é a própria entrada, os autoencoders aprendem com dados não rotulados, uma forma de aprendizado não supervisionado geralmente classificada hoje como aprendizado autossupervisionado. O que torna a rede útil é uma restrição que a impede de simplesmente copiar a entrada, como um gargalo estreito, ruído adicionado, entradas mascaradas ou uma penalidade de esparsidade, forçando-a a aprender a estrutura que permite comprimir os dados. Os autoencoders são usados para redução de dimensionalidade, detecção de anomalias, remoção de ruído, pré-treinamento e como etapa de compressão dos modernos geradores de imagens.

Como funcionam os autoencoders#

O codificador f mapeia uma entrada x para um código z = f(x), o decodificador g produz uma reconstrução x̂ = g(z), e o treinamento minimiza uma perda de reconstrução, como o erro quadrático médio entre x e x̂, usando retropropagação. Em um autoencoder subcompleto, z tem muito menos dimensões que x; assim, o código é um resumo do espaço latente que conserva apenas o necessário para o decodificador. Um autoencoder linear treinado com erro quadrático aprende o mesmo subespaço que a análise de componentes principais (PCA), um resultado demonstrado por Pierre Baldi e Kurt Hornik em 1989, e as funções de ativação não lineares permitem que autoencoders mais profundos capturem estruturas curvas que a PCA não consegue. Em um artigo publicado na Science em 2006, Geoffrey Hinton e Ruslan Salakhutdinov mostraram que autoencoders profundos produziam códigos de baixa dimensão muito melhores que a PCA para imagens e documentos.

As variantes que não dependem de um gargalo estreito corrompem a entrada e ainda avaliam a reconstrução em relação ao original limpo:

Tipos de autoencoders#

• Desnoising: Adiciona ruído à entrada e treina a rede para recuperar o original limpo, como Pascal Vincent e colegas descreveram em 2008. As características aprendidas são robustas à corrupção, e o modelo treinado pode limpar imagens ou sinais ruidosos.
• Esparso: Usa mais unidades de código do que entradas, mas penaliza a quantidade de unidades ativas ao mesmo tempo. Autoencoders esparsos treinados nas ativações internas de modelos de linguagem grandes (LLMs) dividem-nas em muitas características que tendem a corresponder, cada uma, a um conceito interpretável.
• Variacional (VAE): O codificador produz uma distribuição de probabilidade sobre os códigos, e uma penalidade de divergência KL mantém-na próxima de uma distribuição normal padrão, de modo que decodificar um código amostrado aleatoriamente gera novos dados. Diederik Kingma e Max Welling apresentaram o VAE em 2013.
• Quantizado por vetores (VQ-VAE): Ajusta cada vetor de código à entrada mais próxima de um codebook aprendido por meio da quantização vetorial, convertendo imagens ou áudio em tokens discretos que um modelo autorregressivo pode gerar.
• Mascarado: Oculta a maior parte da entrada e reconstrói as partes que faltam. Autoencoders mascarados (MAE) ocultam 75% dos patches de uma imagem, e o codificador treinado dessa forma torna-se um backbone robusto para outras tarefas de visão. O Segment Anything Model (SAM) da Meta, executado no pacote Ultralytics, constrói seu codificador de imagem com base em um Vision Transformer pré-treinado com MAE, e o SAM 2 usa um codificador Hiera pré-treinado com MAE; assim, as características por trás de cada máscara orientada por prompts foram inicialmente aprendidas ao preencher patches ocultos.

Deteção de anomalias com erro de reconstrução#

Um autoencoder treinado apenas com dados normais reconstrói bem as entradas normais e mal as desconhecidas; por isso, o erro de reconstrução funciona como pontuação de anomalia para defeitos de fabricação, transações fraudulentas ou máquinas com falhas, sem precisar de anomalias rotuladas. O trecho de código PyTorch abaixo treina um autoencoder pequeno com os dígitos manuscritos incluídos no scikit-learn, excluindo todos os 7, e compara o erro em dígitos reservados para teste com o erro nos 7:

import torch
from sklearn.datasets import load_digits
from torch import nn

# 8x8 handwritten digits scaled to [0, 1]; every 7 is held out as the unseen anomaly
digits = load_digits()
x = torch.tensor(digits.data / 16, dtype=torch.float32)
normal, sevens = x[digits.target != 7], x[digits.target == 7]
train, test = normal[:1200], normal[1200:]

# Encoder: 64 pixels to an 8-number code; decoder: code back to 64 pixels
torch.manual_seed(0)
encoder = nn.Sequential(nn.Linear(64, 32), nn.ReLU(), nn.Linear(32, 8))
decoder = nn.Sequential(nn.Linear(8, 32), nn.ReLU(), nn.Linear(32, 64), nn.Sigmoid())
model = nn.Sequential(encoder, decoder)
optimizer = torch.optim.Adam(model.parameters(), lr=0.01)
for step in range(1000):
    optimizer.zero_grad()
    nn.functional.mse_loss(model(train), train).backward()  # reconstruction error
    optimizer.step()

with torch.no_grad():
    for name, data in [("Held-out digits", test), ("Unseen 7s", sevens)]:
        print(f"{name}: reconstruction error {nn.functional.mse_loss(model(data), data):.4f}")

O trecho imprime um erro de reconstrução de 0.0163 para os dígitos reservados para teste e de 0.0547 para os 7, em média 3,4 vezes maior; um limiar aplicado ao erro de cada imagem transforma essa diferença num sinalizador de anomalia. Um autoencoder também pode generalizar demasiado bem e reconstruir algumas anomalias com precisão, por isso os sistemas práticos ajustam o tamanho do gargalo e o limiar com dados de validação que incluem anomalias conhecidas.

Autoencoders em comparação com conceitos relacionados#

• Redes adversárias generativas (GANs): Um gerador GAN transforma ruído aleatório em dados e aprende com um discriminador, sem codificador nem objetivo de reconstrução. Os VAEs também geram dados; o objetivo baseado em verossimilhança permite um treino mais estável, mas tende a produzir imagens mais desfocadas.
• U-Net: Tem a estrutura de codificador-decodificador, mas mapeia a entrada para um alvo diferente, como uma máscara de segmentação, e contorna o gargalo com conexões de atalho, que num autoencoder permitiriam à rede copiar a entrada.
• Aprendizagem contrastiva: Aprende representações comparando amostras entre si; assim, as características captam o que distingue as imagens e ignoram detalhes ao nível dos píxeis que uma função de perda de reconstrução teria de preservar.
• Embeddings: O código produzido por um codificador é um tipo de embedding, e os autoencoders são uma das várias formas de os aprender.

Autoencoders na geração de imagens#

Modelos de difusão latente, como o Stable Diffusion, executam o processo de difusão no espaço latente de um autoencoder e, no fim, descodificam o resultado novamente em píxeis. O Stable Diffusion 1.x usa um autoencoder regularizado por KL que comprime uma imagem RGB de 512×512 num latente de 64×64×4, ou seja, 48 vezes menos valores para o modelo de difusão processar em cada etapa de remoção de ruído.