Matryoshka Representation Learning (MRL)
Il Matryoshka Representation Learning addestra embedding le cui dimensioni iniziali funzionano anche da sole, così un vettore può essere troncato per ridurre i costi di archiviazione e ricerca.
L'apprendimento delle rappresentazioni Matrioska (MRL) è un metodo di addestramento che rende utilizzabili come rappresentazione autonoma le dimensioni iniziali di un embedding. Un modello addestrato con MRL produce un unico vettore, ad esempio lungo 768 dimensioni, di cui le prime 512, 256 o 128 possono essere troncate e usate direttamente per la ricerca o la classificazione, con un calo graduale dell'accuratezza man mano che il vettore si restringe. Il nome deriva dalle bambole russe a incastro. Kusupati et al. hanno presentato Matryoshka Representation Learning a NeurIPS 2022 e hanno riportato embedding fino a 14 volte più piccoli a parità di accuratezza di classificazione su ImageNet-1K, oltre a un recupero su larga scala fino a 14 volte più veloce.
Come funziona MRL#
Un modello di embedding standard applica la sua funzione di perdita all'intero vettore, distribuendo così le informazioni su tutte le dimensioni: ogni troncamento ne scarta una parte. MRL seleziona una serie di dimensioni annidate, in genere raddoppiando da 8 fino alla larghezza completa, applica la perdita del compito a ogni prefisso dell'embedding e somma le perdite. Ogni prefisso deve risolvere il compito da solo, spingendo così le informazioni più utili nelle dimensioni iniziali. L'encoder continua a essere eseguito una sola volta per input, quindi il costo di addestramento è solo di poco superiore; la variante efficiente MRL-E condivide un singolo classificatore tra le dimensioni e ogni prefisso usa le prime colonne della sua matrice dei pesi. L'esempio seguente addestra un modello standard e uno MRL sulle cifre manoscritte di scikit-learn e classifica l'insieme di test usando embedding troncati:
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)))Con tutte le 64 dimensioni, entrambi i modelli raggiungono un'accuratezza di 0.91 sul test. Ridotto a 4 dimensioni, il modello standard scende a 0.43, mentre quello MRL mantiene 0.88; con 2 dimensioni i punteggi sono 0.22 e 0.66.
Recupero adattivo#
MRL riduce il costo della ricerca vettoriale in due modi. Memorizzare solo un prefisso riduce proporzionalmente un database vettoriale; inoltre, il recupero adattivo, o a imbuto, cerca nell'intera raccolta con un prefisso breve e poi ricalcola i punteggi di una rosa ristretta usando i vettori completi. Prima di calcolare la similarità coseno o i prodotti scalari, i vettori troncati devono essere nuovamente normalizzati a lunghezza unitaria. Ultralytics Platform esegue la ricerca di embedding nei dataset: l'azione Trova immagini simili confronta gli embedding di ogni immagine nei dataset pubblici, personali e dei team e restituisce fino a 24 immagini più vicine con i rispettivi punteggi di similarità. È un indice condiviso, il cui uso di memoria e costo di ricerca crescono con ogni dimensione dell'embedding.
MRL e concetti correlati#
- Riduzione della dimensionalità: metodi come l'analisi delle componenti principali (PCA) adattano una proiezione a un insieme fisso di vettori dopo l'addestramento; la proiezione deve poi essere memorizzata e applicata a ogni nuovo vettore. MRL integra l'ordinamento nell'addestramento, perciò basta ritagliare il vettore.
- Quantizzazione vettoriale: memorizza ogni vettore con meno bit anziché con meno dimensioni. Le due tecniche si possono combinare, ad esempio usando prefissi MRL quantizzati in binario per una ricerca iniziale.
- Potatura dei modelli e distillazione della conoscenza: riducono il modello che produce gli embedding. MRL lascia invariato l'encoder e riduce solo il suo output.
- Reranker: un modello separato e più costoso che ricalcola i punteggi di una rosa ristretta. Il recupero adattivo ottiene una versione meno costosa dello stesso schema a due fasi usando un unico embedding MRL.
MRL nei modelli di embedding#
I modelli text-embedding-3 di OpenAI, pubblicati nel gennaio 2024, supportano l'accorciamento degli embedding tramite un parametro dimensions; text-embedding-3-large ridotto a 256 dimensioni supera comunque text-embedding-ada-002 a 1,536 dimensioni sul benchmark MTEB. Sentence Transformers addestra modelli MRL con il suo MatryoshkaLoss, descritto nell'introduzione ai modelli di embedding Matrioska di Hugging Face. EmbeddingGemma di Google, un modello di embedding testuale con circa 300 milioni di parametri, produce 768 dimensioni e, grazie al troncamento MRL, offre anche 512, 256 e 128 dimensioni.










