Matryoshka Representation Learning (MRL)
O aprendizado de representações Matryoshka treina embeddings cujas dimensões iniciais funcionam isoladamente, permitindo truncar um vetor para reduzir os custos de armazenamento e busca.
O aprendizado de representações Matryoshka (MRL) é um método de treinamento que torna as dimensões iniciais de um embedding utilizáveis como um embedding independente. Um modelo treinado com MRL gera um vetor — por exemplo, com 768 dimensões — cujos primeiros 512, 256 ou 128 valores podem ser cortados e usados diretamente para busca ou classificação, com a precisão diminuindo gradualmente à medida que o vetor encolhe. O nome vem das bonecas russas encaixáveis. Kusupati et al. apresentaram o aprendizado de representações Matryoshka na NeurIPS 2022 e relataram embeddings até 14 vezes menores com a mesma precisão de classificação no ImageNet-1K, além de recuperação em larga escala até 14 vezes mais rápida.
Como funciona o MRL#
Um modelo de embedding padrão aplica sua função de perda ao vetor completo, de modo que a informação se espalha por todas as dimensões e qualquer truncamento descarta parte dela. O MRL escolhe um conjunto de tamanhos aninhados, normalmente dobrando de 8 até a largura total, aplica a perda da tarefa a cada prefixo do embedding e soma as perdas. Cada prefixo precisa resolver a tarefa por conta própria, o que concentra as informações mais úteis nas primeiras dimensões. O codificador continua executando uma vez por entrada, então o treinamento custa pouco mais do que antes; além disso, a variante eficiente MRL-E compartilha um único classificador entre os tamanhos, e cada prefixo usa as primeiras colunas da matriz de pesos. O exemplo abaixo treina um modelo padrão e um modelo MRL com os dígitos manuscritos do scikit-learn e classifica o conjunto de teste usando embeddings truncados:
import torch
import torch.nn.functional as F
from sklearn.datasets import load_digits
torch.manual_seed(0)
x, y = load_digits(return_X_y=True)
x, y = torch.tensor(x / 16, dtype=torch.float32), torch.tensor(y)
n, dims = 1400, [2, 4, 8, 16, 64] # train/test split and nested prefixes of a 64-dim embedding
for nested in (False, True):
encoder = torch.nn.Sequential(torch.nn.Linear(64, 256), torch.nn.ReLU(), torch.nn.Linear(256, 64))
head = torch.nn.Linear(64, 10) # shared classifier: its first d columns score a d-dim prefix
optimizer = torch.optim.Adam([*encoder.parameters(), *head.parameters()], lr=1e-3)
sizes = dims if nested else [64] # MRL adds a loss for every prefix, a standard model only for all 64
for step in range(500):
z = encoder(x[:n])
loss = sum(F.cross_entropy(z[:, :d] @ head.weight[:, :d].T + head.bias, y[:n]) for d in sizes)
optimizer.zero_grad()
loss.backward()
optimizer.step()
z = encoder(x[n:]).detach() # test embeddings, classified from each truncated prefix
accuracy = [((z[:, :d] @ head.weight[:, :d].T + head.bias).argmax(1) == y[n:]).float().mean() for d in dims]
print("MRL: " if nested else "Standard:", ", ".join(f"{d}d {a:.2f}" for d, a in zip(dims, accuracy)))Ambos os modelos alcançam precisão de teste de 0.91 com as 64 dimensões. Truncado para 4 dimensões, o modelo padrão cai para 0.43, enquanto o modelo MRL mantém 0.88; com 2 dimensões, as pontuações são 0.22 e 0.66.
Recuperação adaptativa#
O MRL torna a busca vetorial mais barata de duas maneiras. Armazenar apenas um prefixo reduz proporcionalmente um banco de dados vetorial, e a recuperação adaptativa, ou em funil, pesquisa toda a coleção com um prefixo curto e depois recalcula as pontuações de uma lista reduzida usando os vetores completos. Os vetores truncados precisam ser novamente normalizados para comprimento unitário antes do cálculo da similaridade de cosseno ou de produtos escalares. A Ultralytics Platform executa busca por embeddings em conjuntos de dados: sua ação Encontrar imagens semelhantes compara embeddings por imagem em conjuntos de dados públicos, pessoais e de equipe, e retorna até 24 das imagens mais próximas com suas pontuações de similaridade; trata-se de um índice compartilhado cujo uso de memória e custo de busca crescem com cada dimensão do embedding.
MRL e conceitos relacionados#
- Redução de dimensionalidade: Métodos como a análise de componentes principais (PCA) ajustam uma projeção a um conjunto fixo de vetores após o treinamento, e é preciso armazenar a projeção e aplicá-la a cada novo vetor. O MRL incorpora a ordenação ao treinamento, então o truncamento é apenas um recorte.
- Quantização vetorial: Armazena cada vetor com menos bits, em vez de menos dimensões. Os dois métodos podem ser combinados, por exemplo, usando prefixos MRL quantizados em binário para uma busca inicial.
- Poda de modelos e destilação de conhecimento: Reduzem o modelo que produz os embeddings. O MRL mantém o codificador inalterado e reduz apenas sua saída.
- Reclassificador: Um modelo separado e mais caro que recalcula as pontuações de uma lista reduzida. A recuperação adaptativa obtém uma versão mais barata do mesmo processo em duas etapas a partir de um único embedding MRL.
MRL em modelos de embedding#
Os modelos text-embedding-3 da OpenAI, lançados em janeiro de 2024, permitem reduzir o tamanho dos embeddings com um parâmetro dimensions; o text-embedding-3-large reduzido para 256 dimensões ainda supera o text-embedding-ada-002 de 1,536 dimensões no benchmark MTEB. O Sentence Transformers treina modelos MRL com seu MatryoshkaLoss, apresentado na introdução aos modelos de embedding Matryoshka da Hugging Face. O EmbeddingGemma do Google, um modelo de embedding de texto com cerca de 300 milhões de parâmetros, gera 768 dimensões e oferece 512, 256 e 128 por meio do truncamento MRL.










