Hypernetworks

Uma hiper-rede é uma rede neural cuja saída corresponde aos pesos de outra rede, chamada rede-alvo ou rede principal. Em vez de aprender um conjunto fixo de pesos do modelo, a rede-alvo recebe pesos calculados pela hiper-rede a partir de uma entrada de condicionamento, como um identificador de tarefa, um perfil de utilizador, uma descrição textual ou uma imagem de exemplo, para que uma única hiper-rede treinada possa produzir um modelo especializado diferente para cada entrada numa passagem direta. No artigo HyperNetworks, publicado pela Google Brain em 2016, David Ha, Andrew Dai e Quoc Le usaram pequenas hiper-redes para gerar os pesos de redes profundas convolucionais e recorrentes; atualmente, a ideia também surge na aprendizagem contínua, na personalização de modelos de difusão e na pesquisa de arquiteturas neurais.

Como funcionam as hiper-redes#

Durante o treino, só se aprendem os parâmetros da própria hiper-rede. A entrada de condicionamento, muitas vezes uma representação vetorial aprendida para cada tarefa ou camada, passa pela hiper-rede para produzir os pesos da rede-alvo; a rede-alvo processa os dados propriamente ditos com esses pesos, e a retropropagação leva o gradiente da perda, através dos pesos gerados, de volta à hiper-rede:

Ha e colegas distinguiram as hiper-redes estáticas, que geram os pesos de cada camada uma vez a partir de um embedding da camada, das hiper-redes dinâmicas, que recalculam os pesos para cada entrada ou passo temporal, como fazia a HyperLSTM a cada passo de uma sequência. Os pesos gerados são tensores comuns em tempo de execução, pelo que a rede-alvo pode ter qualquer arquitetura, incluindo uma camada transformer cujas projeções de atenção vêm da hiper-rede. O principal desafio de engenharia é o tamanho da saída: uma camada com milhões de pesos exigiria milhões de saídas da hiper-rede por camada. As abordagens práticas geram os pesos em blocos, cada um a partir do seu próprio embedding, geram apenas pequenos fatores de baixo posto para cada atualização de pesos ou geram apenas uma escala e um deslocamento por canal, como na modulação linear por características (FiLM).

Exemplo de hiper-rede em PyTorch#

Este exemplo de PyTorch treina uma hiper-rede numa família de tarefas: ondas sinusoidais com diferentes amplitudes e fases. Para cada tarefa, gera os 97 pesos de uma pequena rede-alvo, e só a hiper-rede é treinada:

import math

import torch
from torch import nn

torch.manual_seed(0)
x = torch.linspace(-math.pi, math.pi, 64)

# Hypernetwork: maps a task (amplitude, phase) to all 97 weights of a 1-32-1 target network
hyper = nn.Sequential(nn.Linear(2, 128), nn.ReLU(), nn.Linear(128, 97))
optimizer = torch.optim.Adam(hyper.parameters(), lr=1e-3)


def target(x, w):
    """Run the target network with weights w produced by the hypernetwork."""
    return torch.relu(x[:, None] * w[:32] + w[32:64]) @ w[64:96] + w[96]


# Train only the hypernetwork, on a new random sine task at every step
for step in range(5000):
    task = torch.rand(2) * torch.tensor([2.0, math.pi])
    loss = ((target(x, hyper(task)) - task[0] * torch.sin(x + task[1])) ** 2).mean()
    optimizer.zero_grad()
    loss.backward()
    optimizer.step()

# Unseen task: one forward pass of the hypernetwork produces the target network's weights
y = 1.5 * torch.sin(x + 1.0)
with torch.no_grad():
    mse = ((target(x, hyper(torch.tensor([1.5, 1.0]))) - y) ** 2).mean()
print(f"Unseen task MSE: {mse:.3f} with generated weights, {(y**2).mean():.3f} predicting zero")

Imprime Unseen task MSE: 0.010 with generated weights, 1.132 predicting zero. A rede-alvo para amplitude 1,5 e fase 1,0 nunca foi treinada; os seus pesos resultaram de uma única chamada à hiper-rede, que aprendeu como os pesos adequados variam em toda a família de tarefas.

Aplicações#

• Aprendizagem contínua: Uma hiper-rede condicionada pela tarefa armazena um pequeno embedding para cada tarefa e regenera os pesos dessa tarefa a pedido. O treino numa nova tarefa inclui uma penalização que mantém inalteradas as saídas da hiper-rede para embeddings de tarefas anteriores, o que combate o esquecimento catastrófico.
• Personalização de modelos generativos: O HyperDreamBooth prevê um pequeno conjunto de pesos personalizados para um modelo de difusão de texto para imagem a partir de uma única fotografia de um rosto e, depois, aperfeiçoa-os brevemente. Assim, personaliza o modelo em cerca de 20 segundos, 25 vezes mais depressa do que o DreamBooth, com pesos personalizados 10 000 vezes menores do que um modelo DreamBooth.
• Pesquisa de arquiteturas neurais: As hiper-redes de grafos leem uma arquitetura candidata como um grafo e preveem os seus pesos, permitindo ordenar os candidatos pela respetiva precisão de validação com pesos previstos, em vez de os treinar um a um.
• Classificação zero-shot: Os autores do CLIP descrevem o codificador de texto como uma hiper-rede que gera os pesos de um classificador linear a partir dos nomes das classes, permitindo ao CLIP classificar imagens em categorias que nunca viu como rótulos de treino.

Os detetores de vocabulário aberto aplicam a mesma ideia à deteção. O Ultralytics YOLOE-26, baseado no YOLO26, codifica uma vez cada nome de classe passado a set_classes() com o MobileCLIP2, um codificador de texto compacto ao estilo do CLIP, e usa os embeddings resultantes como pesos para pontuar cada região candidata em relação a cada classe. A exportação incorpora esses embeddings numa convolução 1x1 comum na cabeça de deteção.

Hiper-redes e termos relacionados#

• Ajuste fino: Adapta um conjunto fixo de pesos a uma nova tarefa com passos de gradiente sobre os dados dessa tarefa. Uma hiper-rede treinada produz pesos para uma nova tarefa numa única passagem direta, recebendo apenas a entrada de condicionamento da tarefa.
• Meta-aprendizagem: O objetivo mais amplo de aprender a adaptar-se rapidamente a novas tarefas. As hiper-redes são uma forma de implementar este objetivo, mapeando diretamente uma descrição da tarefa ou alguns exemplos para pesos.
• Mistura de especialistas (MoE): Encaminha cada entrada para alguns de muitos submodelos especialistas fixos. Em vez de selecionar entre especialistas armazenados, uma hiper-rede calcula novos pesos para cada entrada ou tarefa.
• Programadores de pesos rápidos: Redes que escrevem os pesos de curto prazo de outra rede à medida que uma sequência é processada; uma ideia do início da década de 1990. A autoatenção linearizada em transformers é formalmente equivalente a um programador de pesos rápidos.