Matryoshka Representation Learning (MRL)
L’apprentissage de représentations Matryoshka entraîne des plongements dont les premières dimensions sont utiles seules, de sorte qu’un même vecteur peut être tronqué pour réduire les coûts de stockage et de recherche.
L'apprentissage de représentations Matryoshka (MRL) est une méthode d'entraînement qui rend les premières dimensions d'un plongement utilisables comme plongement à part entière. Un modèle entraîné avec MRL produit un vecteur, par exemple de 768 dimensions, dont les 512, 256 ou 128 premières valeurs peuvent être tronquées et utilisées directement pour la recherche ou la classification, avec une baisse progressive de la précision à mesure que le vecteur rétrécit. Le nom vient des poupées russes gigognes. Kusupati et al. ont présenté Matryoshka Representation Learning à NeurIPS 2022 et ont rapporté des plongements jusqu'à 14 fois plus petits à précision de classification égale sur ImageNet-1K, ainsi qu'une récupération à grande échelle jusqu'à 14 fois plus rapide.
Fonctionnement de MRL#
Un modèle de plongement standard applique sa fonction de perte au vecteur entier ; l'information se répartit donc sur toutes les dimensions et toute troncature en élimine une partie. MRL choisit un ensemble de tailles imbriquées, généralement doublées de 8 jusqu'à la largeur totale, applique la perte de la tâche à chaque préfixe du plongement, puis additionne les pertes. Chaque préfixe doit résoudre la tâche à lui seul, ce qui concentre l'information la plus utile dans les premières dimensions. L'encodeur ne s'exécute qu'une fois par entrée, de sorte que l'entraînement coûte à peine plus qu'auparavant. La variante efficace MRL-E partage un seul classifieur entre les tailles ; chaque préfixe utilise les premières colonnes de sa matrice de poids. L'exemple ci-dessous entraîne un modèle standard et un modèle MRL sur les chiffres manuscrits de scikit-learn, puis classe le jeu de test à partir de plongements tronqués :
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)))Les deux modèles atteignent une précision de test de 0.91 avec les 64 dimensions. Tronqué à 4 dimensions, le modèle standard tombe à 0.43 tandis que le modèle MRL conserve 0.88 ; à 2 dimensions, les scores sont de 0.22 et 0.66.
Récupération adaptative#
MRL réduit le coût de la recherche vectorielle de deux façons. Le stockage d'un préfixe seulement réduit proportionnellement la taille d'une base de données vectorielle, tandis que la récupération adaptative, ou en entonnoir, effectue une recherche dans toute la collection avec un préfixe court, puis réévalue une liste restreinte avec les vecteurs complets. Les vecteurs tronqués doivent être à nouveau normalisés à une longueur unitaire avant de calculer la similarité cosinus ou les produits scalaires. Ultralytics Platform effectue une recherche par plongements dans les jeux de données : son action Trouver des images similaires compare les plongements de chaque image parmi les jeux de données publics, personnels et d'équipe, puis renvoie jusqu'à 24 des images les plus proches avec leurs scores de similarité. Cet index partagé voit ses besoins en mémoire et son coût de recherche augmenter avec chaque dimension des plongements.
MRL et notions connexes#
- Réduction de dimension : Des méthodes comme l'analyse en composantes principales (PCA) ajustent une projection à un ensemble fixe de vecteurs après l'entraînement ; cette projection doit être stockée et appliquée à chaque nouveau vecteur. MRL intègre l'ordre dans l'entraînement, si bien que la troncature se résume à une découpe.
- Quantification vectorielle : Stocke chaque vecteur avec moins de bits plutôt qu'avec moins de dimensions. Les deux méthodes peuvent être combinées, par exemple avec des préfixes MRL quantifiés en binaire pour une recherche initiale.
- Élagage de modèle et distillation de connaissances : Réduisent la taille du modèle qui produit les plongements. MRL laisse l'encodeur inchangé et ne réduit que sa sortie.
- Modèle de reclassement : Modèle distinct, plus coûteux, qui réévalue une liste restreinte de résultats. La récupération adaptative applique une version moins coûteuse du même schéma à deux étapes à partir d'un seul plongement MRL.
MRL dans les modèles de plongement#
Les modèles text-embedding-3 d'OpenAI, publiés en janvier 2024, permettent de raccourcir les plongements au moyen du paramètre dimensions ; text-embedding-3-large, réduit à 256 dimensions, surpasse encore le modèle text-embedding-ada-002 de 1,536 dimensions sur le test de référence MTEB. Sentence Transformers entraîne des modèles MRL avec son MatryoshkaLoss, présenté dans l'introduction de Hugging Face aux modèles de plongement Matryoshka. EmbeddingGemma de Google, un modèle de plongement de texte d'environ 300 millions de paramètres, produit 768 dimensions et propose les tailles 512, 256 et 128 par troncature MRL.










