Redes Siamesas

Visão geral

Uma rede siamesa (Siamese network) é uma arquitetura neural (neural architecture) construída a partir de duas (ou mais) sub-redes idênticas que compartilham pesos (weight sharing). Cada ramo processa uma entrada e produz uma representação vetorial (embedding) (uma representação em vetor). A rede é treinada para que entradas semelhantes mapeiem para representações vetoriais próximas e entradas diferentes mapeiem para representações vetoriais distantes. Em vez de prever rótulos de classe diretamente, redes siamesas aprendem uma função de similaridade (similarity function) em um espaço de representações—tornando-as especialmente úteis para tarefas de verificação (verification), correspondência (matching) e recuperação (retrieval).

Casos de uso comuns incluem:

  • Verificação facial (“Essas duas faces são da mesma pessoa?”)
  • Rastreamento de objetos (“Para onde este objeto se moveu no próximo frame?”)
  • Reconhecimento one-shot / few-shot
  • Aprendizado de métricas (metric learning) geral para recuperação por vizinho mais próximo

Redes siamesas são melhor entendidas como um padrão de arquitetura em vez de um único modelo fixo: você pode construí-las com redes neurais convolucionais (CNNs), modelos Transformer (Transformers) ou qualquer rede base (backbone) que produza representações vetoriais.

Ideia central: compartilhamento de pesos + aprendizado de métricas

Compartilhamento de pesos

Ambos os ramos usam os mesmos parâmetros:

  • Garante que ambas as entradas sejam incorporadas no mesmo espaço de características
  • Reduz parâmetros (em relação a duas redes independentes)
  • Melhora a generalização: o modelo não consegue “trapacear” aprendendo extratores de características diferentes para cada lado

Esse compartilhamento de pesos é a característica definidora de uma rede siamesa “verdadeira”. (Parte da literatura também usa “pseudo-siamesa (pseudo-Siamese)” para descrever modelos de dois ramos sem pesos compartilhados.)

Representações vetoriais e distâncias

Considere um codificador (encoder) ( f_\theta(\cdot) ) que mapeia uma entrada (x) para uma representação vetorial (z):

[ z = f_\theta(x) \in \mathbb{R}^d ]

Dadas duas entradas (x_1, x_2), calculamos:

[ z_1 = f_\theta(x_1), \quad z_2 = f_\theta(x_2) ]

Então medimos similaridade via uma função de distância ou similaridade:

  • Distância euclidiana (Euclidean distance): ( |z_1 - z_2|_2 )
  • Similaridade cosseno (cosine similarity): ( \frac{z_1^\top z_2}{|z_1||z_2|} ) (frequentemente com representações vetoriais normalizadas em L2)
  • Comparador aprendido (um perceptron multicamadas (MLP) sobre ([z_1, z_2, |z_1-z_2|]), etc.)

O sistema pode ser usado de duas formas principais:

  1. Verificação: produzir um escore de similaridade e comparar com um limiar.
  2. Recuperação: gerar a representação vetorial de uma consulta e, então, buscar os vizinhos mais próximos em um banco de dados indexado.

Isso está intimamente relacionado ao aprendizado de métricas, em que o objetivo é aprender um espaço de representações no qual distâncias correspondam à similaridade semântica.

Padrões de arquitetura

Rede base compartilhada (codificador)

Cada ramo tipicamente é um extrator de características (feature extractor) como:

Frequentemente, você começará a partir de uma rede base pré-treinada (pretrained backbone) (por exemplo, uma CNN pré-treinada no ImageNet) e fará ajuste fino (fine-tune) com um objetivo de aprendizado de métricas.

Cabeça de embedding (projeção)

Redes base frequentemente produzem características de alta dimensionalidade; sistemas siameses comumente adicionam uma “cabeça de embedding”:

  • Camada(s) linear(es) → dimensão (d) (por exemplo, 128, 256, 512)
  • Não linearidade opcional (ReLU/GELU)
  • Normalização opcional (a norma L2 é comum ao usar similaridade cosseno)

Por que adicionar uma cabeça?

  • Controla o tamanho e a geometria da representação vetorial
  • Separa “características gerais” de “características do espaço métrico”
  • Pode estabilizar o treinamento (especialmente ao fazer ajuste fino em redes base grandes)

Cabeça de distância / comparador

Há dois estilos amplos:

  1. Apenas métrica (sem comparador aprendido):

    • Calcular distância/similaridade diretamente nas representações vetoriais.
    • O treinamento usa objetivos contrastivos ou de tríplice.
    • Muito comum em recuperação e verificação.

  2. Cabeça comparadora aprendida:

    • Alimentar ([z_1, z_2]), (|z_1-z_2|) ou (z_1 \odot z_2) em um MLP para produzir uma probabilidade de correspondência.
    • Isso se aproxima de um modelo de duas torres (two-tower model) mais um classificador (classifier).
    • Pode funcionar bem quando “similaridade” é específica da tarefa e não é bem capturada por uma métrica simples.

Como regra prática:

  • Para recuperação e busca por vizinhos mais próximos, prefira apenas métrica + representações vetoriais normalizadas.
  • Para correspondência binária com pistas complexas, uma cabeça aprendida pode ajudar (mas pode generalizar menos como um espaço de representações reutilizável).

Objetivos de treinamento

Redes siamesas são treinadas construindo relações entre exemplos (pares ou tríplices) em vez de exemplos rotulados individualmente. Duas perdas clássicas são perda contrastiva (contrastive loss) e perda de tríplice (triplet loss).

Perda contrastiva (baseada em pares)

Você treina em pares ((x_i, x_j)) com rótulo (y \in {0,1}), onde:

  • (y=1): mesma classe / correspondência
  • (y=0): classes diferentes / não correspondência

Seja (D = |z_i - z_j|_2). Uma perda contrastiva comum é:

[ \mathcal{L} = y \cdot D^2 + (1-y)\cdot \max(0, m - D)^2 ]

  • Para pares positivos ((y=1)), as representações vetoriais são puxadas para mais perto.
  • Para pares negativos ((y=0)), as representações vetoriais são empurradas para longe até ficarem pelo menos a uma margem (m) de distância.

Notas práticas:

  • A margem (m) importa; pequena demais → separação fraca, grande demais → treinamento instável.
  • Você deve amostrar cuidadosamente negativos significativos; negativos aleatórios podem se tornar “fáceis demais” cedo.

Perda de tríplice (âncora–positivo–negativo)

O treinamento por tríplices usa:

  • Âncora (x_a)
  • Positivo (x_p) (mesma identidade/classe que a âncora)
  • Negativo (x_n) (identidade/classe diferente)

Com distância (D(u,v)=|u-v|_2), a perda de tríplice clássica é:

[ \mathcal{L} = \max\left(0, D(z_a, z_p) - D(z_a, z_n) + \alpha \right) ]

onde (\alpha) é a margem.

Interpretação:

  • Garantir que o negativo esteja pelo menos (\alpha) mais distante da âncora do que o positivo.

Por que tríplices?

  • Elas codificam restrições relativas, frequentemente mais alinhadas com ranking/recuperação.
  • Podem produzir representações vetoriais fortes—mas exigem boas estratégias de mineração.

Além dos clássicos (comum no aprendizado de métricas moderno)

Embora “rede siamesa” frequentemente implique treinamento contrastivo/por tríplices, sistemas modernos usam variantes com frequência:

  • InfoNCE / NT-Xent (perda contrastiva com múltiplos negativos), comum em Aprendizado Contrastivo e Aprendizado Auto-Supervisionado, onde “pares positivos” são aumentações do mesmo exemplo e todas as outras amostras do lote se tornam negativas.
  • Perdas N-pair / de multi-similaridade para melhor eficiência por lote.
  • Perdas no estilo classificação com representações vetoriais normalizadas (por exemplo, softmax com margem em reconhecimento facial). Nem sempre são chamadas de “siamesas”, mas atendem ao mesmo objetivo de embedding-verificação.

Construção de dados: pares, tríplices e mineração

O maior desafio prático é que o número de pares/tríplices possíveis cresce de forma combinatória.

Estratégias de amostragem de pares

  • Pares balanceados: manter uma proporção 1:1 ou uma razão controlada de pares positivos/negativos.
  • Pareamento dentro do lote: criar pares a partir de itens já no minilote (minibatch) (eficiente).
  • Currículo: começar com negativos mais fáceis e então aumentar a dificuldade.

Estratégias de mineração de tríplices

O desempenho da perda de tríplice depende fortemente da escolha de negativos:

  • Negativos fáceis: já estão longe → a perda é zero → computação desperdiçada.
  • Negativos difíceis: mais próximos do que positivos → gradiente forte, mas pode desestabilizar o treinamento cedo.
  • Negativos semi-difíceis: mais distantes que positivos, mas ainda dentro da margem → frequentemente um bom compromisso.

Técnicas comuns:

  • Mineração de tríplices batch-hard (Batch-hard triplet mining): em cada lote, para cada âncora escolher o positivo mais difícil e o negativo mais difícil dentro do lote.
  • Banco de memória / cache de representações vetoriais (memory bank / embedding cache): manter uma fila de representações vetoriais para amostrar negativos.

A mineração é conceitualmente similar à Mineração de Negativos Difíceis: o treinamento foca nos casos confusos que moldam a fronteira de decisão.

Escolhas práticas de projeto e trade-offs

Escolha da métrica de distância

  • Similaridade cosseno + normalização L2 (L2 normalization) é muito comum porque estabiliza a escala e facilita a definição de limiares.
  • Distância euclidiana também funciona bem, especialmente quando as representações vetoriais são normalizadas (cosseno e euclidiana se tornam fortemente relacionadas sob normalização).

Regra prática:

  • Se você planeja usar busca por vizinho mais próximo (nearest neighbor search) em escala, representações vetoriais normalizadas simplificam indexação e seleção de limiar.

Dimensão da representação vetorial

Valores típicos:

  • 128 / 256 / 512 para imagens e faces
  • Dimensões maiores podem ajudar em domínios complexos, mas aumentam custo de armazenamento e recuperação

Se a representação vetorial for pequena demais, identidades diferentes colapsam; se for grande demais, o espaço pode sobreajustar.

Pré-treinamento e congelamento

Uma receita muito comum:

  1. Começar a partir de uma rede base pré-treinada (por exemplo, ImageNet).
  2. Adicionar uma pequena cabeça de embedding.
  3. Inicialmente congelar a maior parte da rede base e treinar a cabeça.
  4. Descongelar e fazer ajuste fino com uma taxa de aprendizado (learning rate) menor.

Isso aproveita características gerais aprendidas por treinamento supervisionado padrão e as refina para estrutura métrica.

Seleção de limiar para verificação

Para verificação (“mesmo” vs “diferente”), você precisa de um limiar (t) sobre distância ou similaridade:

  • Escolher (t) usando um conjunto de validação para atingir uma taxa de falsa aceitação (false accept rate) desejada ou maximizar F1.
  • Métricas comuns: curva ROC (ROC curve), AUC, EER (taxa de erro igual (equal error rate)).

Exemplo mínimo em PyTorch (rede siamesa com perda contrastiva)

Abaixo há um exemplo compacto mostrando o padrão: codificador compartilhado → representações vetoriais → distância → perda contrastiva.

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

class SiameseNet(nn.Module):
    def __init__(self, encoder: nn.Module, emb_dim: int = 256):
        super().__init__()
        self.encoder = encoder  # shared
        self.head = nn.Sequential(
            nn.Linear(encoder.out_dim, emb_dim),
            nn.ReLU(),
            nn.Linear(emb_dim, emb_dim),
        )

    def embed(self, x):
        h = self.encoder(x)
        z = self.head(h)
        z = F.normalize(z, dim=-1)  # useful for cosine similarity
        return z

    def forward(self, x1, x2):
        return self.embed(x1), self.embed(x2)

def contrastive_loss(z1, z2, y, margin=1.0):
    """
    y = 1 for positive pair, 0 for negative pair
    """
    d = torch.norm(z1 - z2, dim=-1)  # Euclidean distance
    pos = y * d.pow(2)
    neg = (1 - y) * F.relu(margin - d).pow(2)
    return (pos + neg).mean()

Na prática, você também precisa de um conjunto de dados que forneça pares ((x_1, x_2, y)), e de um cuidado com o batching para não treinar com a maioria de negativos fáceis.

Aplicações típicas

Verificação facial e reidentificação de pessoas (person re-identification)

Objetivo: determinar se duas imagens de face pertencem à mesma pessoa.

Configuração comum:

  • Treinar um modelo siamesa/por tríplices com rótulos de identidade.
  • Na inferência (inference), gerar a representação vetorial de uma face consulta e comparar com uma galeria (gallery) usando similaridade cosseno.

Por que a abordagem siamesa funciona bem aqui:

  • O espaço de rótulos pode ser enorme (milhões de identidades), e novas identidades aparecem após o treinamento.
  • Verificação baseada em representações vetoriais generaliza melhor para identidades não vistas do que um classificador de conjunto fechado (closed-set classifier).

Rastreamento de objetos (rastreadores siameses)

Em rastreamento de objetos, você recebe um exemplar (template) do alvo no primeiro frame e deve localizá-lo em frames posteriores.

Sistemas de rastreamento siameses (por exemplo, a família SiamFC / SiamRPN) tipicamente:

  • Geram representações vetoriais do template e da região de busca com uma CNN compartilhada.
  • Computam um mapa de similaridade via correlação cruzada (cross-correlation) (uma “cabeça de distância” estruturada).
  • Predizem a melhor localização (e às vezes refinamentos de caixa delimitadora (bounding box refinements)).

Por que a abordagem siamesa é um encaixe natural:

  • Rastreamento é um problema de correspondência: “encontre a região mais semelhante ao template”.
  • O compartilhamento de pesos garante características consistentes entre frames.

Aprendizado one-shot / few-shot

Em classificação few-shot, você pode ter apenas 1–5 exemplos por classe. Representações vetoriais siamesas permitem classificar por proximidade:

  • Calcular representações vetoriais para exemplos de suporte (support examples).
  • Para uma consulta, escolher a classe do embedding de suporte mais próximo (ou usar um protótipo (prototype) por classe).

Isso se conecta a um aprendizado de representações (representation learning) mais amplo e a métodos few-shot baseados em métricas.

Aprendizado de métricas para busca e recuperação

Exemplos:

  • Busca de imagens de produtos (“encontrar itens visualmente semelhantes”)
  • Recuperação de documentos ou sentenças (correspondência no estilo bi-codificador (bi-encoder))
  • Verificação de locutor (speaker verification) (“é o mesmo locutor?”)

Depois de treinado, você pode:

  • Construir um índice de embeddings (por exemplo, busca de vizinho mais próximo aproximado (ANN search))
  • Recuperar vizinhos mais próximos rapidamente
  • Adicionar novos itens sem retreinar (apenas gerar a representação vetorial e inserir)

Avaliação e implantação

Métricas comuns de avaliação

Para verificação:

  • ROC AUC
  • Taxa de aceitação verdadeira com taxa de falsa aceitação fixa
  • Taxa de erro igual (EER)

Para recuperação:

  • Recall@K
  • Precisão média (mAP, mean average precision)
  • NDCG (qualidade de ranking)

Padrão de implantação

Uma configuração típica em produção se parece com:

  1. Offline: gerar representações vetoriais de todos os itens do banco de dados e armazenar os vetores.
  2. Online: gerar a representação vetorial da entrada de consulta.
  3. Calcular vizinhos mais próximos via busca aproximada.
  4. Opcionalmente aplicar um reordenador (reranker) secundário ou regras de negócio (business rules).

Isso costuma ser mais simples e escalável do que executar um codificador cruzado (cross-encoder) que compara a consulta com cada candidato.

Armadilhas e modos de falha comuns

  • Amostragem de negativos ruim (negative sampling): o treinamento satura porque a maioria dos negativos é fácil demais.
  • Colapso das representações vetoriais (collapsed embeddings): tudo mapeia para o mesmo vetor (frequentemente por configuração ruim da perda ou problemas na taxa de aprendizado).
  • Mudança de domínio (domain shift): representações vetoriais aprendidas em um domínio (faces em estúdio) podem falhar em outro (vigilância).
  • Fragilidade do limiar (threshold brittleness): limiares de verificação podem ser sensíveis à iluminação, resolução, demografia ou diferenças de sensor—exigindo validação, monitoramento e calibração cuidadosos.
  • Sobreajuste a rótulos de identidade (overfitting to identity labels): o modelo separa identidades de treino, mas não generaliza para novas; regularização e aumentação de dados (augmentation) fortes ajudam.

Extensões e ideias relacionadas

  • Siamesa multi-ramo (Multi-branch Siamese): mais de duas entradas (por exemplo, redes de tríplices são essencialmente uma siamesa de 3 ramos com pesos compartilhados).
  • Modelos de duas torres (Two-tower models): comuns em sistemas de recomendação e recuperação de texto; arquiteturalmente similares a redes siamesas, às vezes com torres assimétricas.
  • Aprendizado contrastivo auto-supervisionado (Self-supervised contrastive learning): métodos como SimCLR usam uma configuração no estilo siamesa com duas visões aumentadas do mesmo exemplo e muitos negativos no lote; isso é fundamental no Aprendizado Contrastivo moderno.
  • Cabeças de similaridade aprendidas (Learned similarity heads): úteis quando “similaridade” depende de interações complexas; no entanto, podem reduzir a utilidade universal do espaço de representações.

Quando usar uma rede siamesa (e quando não)

Use redes siamesas quando:

  • Você precisa de verificação ou recuperação em vez de classificação de conjunto fechado.
  • Novas classes/identidades aparecem após o treinamento.
  • Você quer um espaço de representações reutilizável para muitas tarefas posteriores.

Considere alternativas quando:

  • A tarefa é estritamente classificação de conjunto fechado com rótulos fixos (um classificador padrão pode ser mais simples).
  • Você precisa de interação rica entre entradas para máxima acurácia (codificadores cruzados podem superar, mas são mais lentos em escala).

Resumo

Redes siamesas são arquiteturas multi-ramo com compartilhamento de pesos projetadas para aprender representações vetoriais em que a distância reflete similaridade semântica. Ao treinar com objetivos como perda contrastiva e perda de tríplice, elas se tornam ferramentas poderosas para verificação, rastreamento e recuperação. O sucesso prático depende menos de camadas exóticas e mais de construção de dados (pares/tríplices), mineração de negativos, escolhas de distância e bons protocolos de avaliação—tornando-as uma ponte altamente prática entre extração de características em deep learning e sistemas reais baseados em similaridade.