Formation tenant compte de la quantification de jina-embeddings-v4

La quantification est une méthode largement utilisée pour résoudre les problèmes de mise à l'échelle en IA. Le nom peut sembler compliqué, mais il s'agit simplement d'arrondir les nombres pour qu'ils prennent moins de place. Cela signifie des vecteurs de modèles (Embeddings) plus petits qui prennent moins de mémoire et d'espace de stockage, et une récupération d'informations plus rapide car il faut moins de temps pour comparer les vecteurs. La quantification est une technique purement numérique qui ne se soucie pas du type de données que votre modèle traite ni de vos cas d'utilisation. Elle peut donc apporter des améliorations sans nécessiter beaucoup de connaissances spécialisées coûteuses.

On pourrait s'attendre à ce que la quantification implique de bons vieux compromis et que rien ne soit gratuit, où nous devons sacrifier une certaine précision. Dans cet article, nous allons vous montrer un moyen de la rendre sans perte grâce à l'apprentissage tenant compte de la quantification (QAT). Cette technique est utilisée dans jina-embeddings-v4 pour fournir des modèles plus petits qui sont nécessaires dans les applications où l'espace est critique.

tagAperçu des techniques de quantification

La quantification de modèle signifie généralement l'une des quatre choses suivantes :

• Quantification post-formation (PTQ)
• Formation pour des sorties de modèles quantifiés (Output QAT)
• Formation pour des modèles entièrement quantifiés (Full QAT)
• Distiller un nouveau modèle quantifié à partir d'un modèle non quantifié existant

La quantification post-formation (PTQ) accepte le modèle de modèles entraîné tel quel et ne le modifie en aucune façon. Il s'agit simplement de jeter les chiffres les moins significatifs des valeurs à virgule flottante produites par le modèle. Nous arrondissons simplement les nombres et les mettons parfois à l'échelle dans une plage.

Output QAT signifie affiner le modèle de modèles pour produire des vecteurs de précision réduite optimaux. Cela signifie modifier le modèle, mais cela ne change pas la précision des poids du modèle, et ne réduit donc pas sa taille. Seule la taille du vecteur de sortie est réduite.

Full QAT commence avec un modèle de pleine précision entièrement formé et réduit la précision des poids du modèle, puis affine les performances de ce modèle modifié. Cela produit un modèle significativement plus petit ainsi que des modèles plus petits, au prix d'un certain affinage.

La distillation est le processus de formation d'un nouveau modèle pour qu'il corresponde aux performances d'un modèle existant. Cela signifie créer un nouveau modèle conçu dès le départ comme quantifié, puis utiliser le modèle existant pour générer autant de données de formation que nécessaire pour l'entraîner jusqu'à ce qu'il fonctionne aussi près que possible du modèle existant.

Les avantages de ces quatre approches sont résumés dans le tableau ci-dessous :

Les quatre approches produisent des modèles plus compacts, mais à part la PTQ, toutes nécessitent une formation supplémentaire, tandis que seules la Full QAT et la distillation produisent de nouveaux modèles plus rapides. La Full QAT et la distillation sont beaucoup plus coûteuses à mettre en œuvre car elles nécessitent beaucoup plus de formation que l'Output QAT.

Dans cet article, nous n'allons examiner que la PTQ et l'Output QAT, qui ne modifient pas la taille ou la vitesse du modèle de modèles.

tagConfiguration expérimentale

Pour ces expériences, notre modèle de base est jina-embeddings-v4 avec l'adaptateur de récupération, qui produit des vecteurs à virgule flottante de précision 32 bits (FP32) en 2048 dimensions. Chaque modèle fait donc 8196 octets, soit 8 Ko.

Nous avons étudié plusieurs conditions expérimentales en utilisant des tâches d'évaluation de la récupération de requêtes-documents de la suite NanoBEIR benchmark. Le processus de récupération utilise la similarité cosinus entre les vecteurs pour trouver et classer les documents qui correspondent le mieux aux requêtes.

• Base de référence — Les performances des vecteurs de modèles jina-embeddings-v4 sans aucune quantification. Ces expériences ont toutes utilisé une version bêta du modèle, et les performances de la version sont légèrement meilleures.
• PTQ — Nous avons quantifié les vecteurs de sortie en vecteurs binaires sans modifier le modèle.
• Output QAT — Nous avons quantifié les vecteurs de sortie et appliqué un affinage à l'adaptateur de récupération pour améliorer ses performances dans des conditions quantifiées.

tagNiveaux de quantification

Nous avons expérimenté quatre niveaux de quantification différents.

• Entiers 8 bits — Les valeurs FP32 sont réduites à des entiers dans la plage de -128 à 127, ce qui réduit les modèles de 4 fois à 2048 octets.
• Entiers 4 bits - Identique aux entiers 4 bits, mais nous mappons à la plage de -8 à 7, ce qui réduit la taille des vecteurs d'un facteur 8, à 1024 octets.
• Quantification trinaire — Toutes les valeurs sont mappées à l'une des trois valeurs : -1, 0, 1. Stocké de manière optimale, cela réduit chaque dimension à 1,6 bit, ce qui réduit la taille des vecteurs de modèles d'environ 40 fois à environ 230 octets.
• Quantification binaire — Nous convertissons les valeurs scalaires FP32 en un bit, en utilisant le type de données torch.sign, qui ne fournit que deux valeurs, prenant un bit à stocker. Cela réduit les vecteurs de modèles 2048 dimensions de 8192 octets à 128 octets, une réduction de 64 fois.

tagMise à l'échelle

Pour la quantification binaire, la quantification est très simple : si une valeur de vecteur est supérieure à 0 ou positive, elle est mappée à 1. Sinon, elle est mappée à -1.

Pour les autres scénarios de quantification, nous avons normalisé les valeurs dans une plage, puis arrondi à la valeur la plus proche autorisée par le niveau de quantification. Les vecteurs de modèles sont constitués de nombres d'échelle entre -∞ et +∞ (ou, en pratique, de très grands nombres positifs et négatifs). Nous utilisons deux nombres, $max$ et $min$, pour mettre à l'échelle les valeurs pour la quantification.

Pour la quantification trinaire, nous prenons chaque composante de vecteur $v$ et la traduisons comme suit :

• si $v$ ≥ $max$, $v$ devient 1.
• si $v$ ≤ $min$, $v$ devient -1.
• si $min$ < $v$ < $max$, $v$ devient 0.

Pour les entiers 4 bits :

• si $v$ ≥ $max$, $v$ devient 7.
• si $v$ ≤ $min$, $v$ devient -8.
• si $min$ < $v$ < $max$, $v$ devient $16*(v - min)/(max - min) - 8$, puis arrondi à l'entier le plus proche. Cela met l'échelle la valeur dans la plage $[-8,7]$.

Pour les entiers 8 bits :

• si $v$ ≥ $max$, $v$ devient 127.
• si $v$ ≤ $min$, $v$ devient -128.
• si $min$ < $v$ < $max$, $v$ devient $256*(v - min)/(max - min) - 128$, arrondi à l'entier le plus proche. Cela met l'échelle la valeur dans la plage $[-128,127]$.

Pour calculer $max$ et $min$, nous avons utilisé deux approches :

• Min/Max — Nous avons traité nos données par lots, et pour chaque lot, nous avons identifié la composante de vecteur la plus élevée et la plus basse, en définissant $max$ sur la plus élevée et $min$ sur la plus basse.
• Moyenne mobile sur les lots — Pour chaque lot, nous avons calculé la moyenne et l'écart type des composantes de vecteur. Nous avons maintenu une moyenne mobile à la fois de la moyenne et de l'écart type au fur et à mesure que nous traitions tous les lots. Si $avg$ est la moyenne mobile actuelle des valeurs moyennes des lots, et $std$ est la moyenne mobile actuelle des écarts types, alors pour chaque lot :

$max = avg + std$
$min = avg - std$

tagAffinage QAT

Pour les expériences PTQ, nous avons utilisé le modèle tel quel et quantifié les modèles qu'il a produits en utilisant les méthodes décrites ci-dessus.

Pour l'Output QAT, nous avons affiné le modèle en utilisant l'estimation directe. Cela signifie que nous inversons le processus de quantification, en restaurant la pleine précision aux valeurs, avant de calculer la perte (c'est-à-dire l'erreur), puis nous utilisons cette métrique de perte pour affiner le modèle.

Nous avons affiné dans chaque cas pendant 10 000 étapes, en sauvegardant un point de contrôle tous les 500 étapes. Nous avons ensuite conservé le point de contrôle avec le score le plus élevé sur le banc d’essai NanoBEIR.

tagQuantification asymétrique

La quantification post-formation (PTQ) et la quantification Output Aware Training (QAT) réduisent la taille des vecteurs du modèle d' 向量模型 (Embeddings), mais ne réduisent pas la taille du modèle ni la vitesse d’inférence ; toutes les économies se trouvent dans la taille des modèles d' 向量模型 (Embeddings) de document stockés et la vitesse de récupération.

Par conséquent, nous avons testé la quantification des vecteurs de requête et le fait de les laisser non quantifiés au moment de la récupération, car cela ne change pas la taille des vecteurs d' 向量模型 (Embeddings) stockés de toute façon.

tagRésultats

Nous avons testé neuf conditions au total, résumées dans les tableaux ci-dessous :

Tableau 2 : Conditions expérimentales

Tableau 3 : Score moyen (en % correct) pour chaque condition sur les douze bancs d’essai NanoBEIR.

Vous pouvez voir dans le tableau ci-dessus que l’affinage pour la quantification améliore les scores. La seule différence entre les conditions PTQ Binaire et QAT Binaire est l’affinage, et la différence de score est significative. De même, nous constatons une amélioration de près de 2 % des scores entre les conditions PTQ Documents binaires uniquement et QAT Documents binaires uniquement, qui ne se distinguent que par le même affinage.

Sans surprise, nous constatons également que les scores s’améliorent généralement moins nous quantifions, la quantification à 4 bits étant meilleure que la ternaire, et la ternaire meilleure que la binaire. Cependant, passer à 8 bits ne semble rien avoir amélioré.

Nous n’avons testé le fait de laisser les requêtes non quantifiées que dans les cas binaires, mais cela semble améliorer les performances.

Enfin, nos tests suggèrent que la méthode de mise à l’échelle de la moyenne glissante surpasse l’approche min./max. simpliste.

tagConclusion

La quantification présente des avantages opérationnels importants pour les modèles d' 向量模型 (Embeddings), en réduisant considérablement la taille des vecteurs d' 向量模型 (Embeddings) et en accélérant la recherche d’informations. Bien que la quantification post-formation simple (PTQ) offre des avantages immédiats en termes de mémoire et de stockage, nos expériences démontrent que la formation tenant compte de la quantification (QAT) atténue considérablement les pertes de précision inévitables. L’affinage a toujours donné de meilleurs scores.

Le degré de quantification a un impact direct sur les performances, ce qui est ce à quoi on s’attendrait d’une méthode basée sur la réduction de la précision des valeurs. Une quantification moins agressive (p. ex., 4 bits) surpasse généralement les méthodes plus agressives (p. ex., binaire), mais étonnamment, il n’y a pas eu de différence significative de performances entre la quantification à 8 bits et à 4 bits. Il semblerait que tant que vous n’atteignez pas un certain seuil d’imprécision, il y ait peu de différence entre une quantification plus ou moins importante.

Les stratégies de mise à l’échelle sont également importantes, la méthode de la moyenne glissante affichant des résultats supérieurs à une approche min./max. fixe. L’utilisation de valeurs de mise à l’échelle relatives aux données semble fonctionner beaucoup mieux et mérite d’être explorée davantage.

La quantification peut vous permettre de tirer davantage de vos modèles d' 向量模型 (Embeddings) pour moins cher. Bien que cet article n’explore pas toutes les options de quantification, il en explore deux qui sont facilement accessibles et qui ont de réels avantages à offrir. Nous nous efforçons d’affiner et d’améliorer les stratégies de quantification afin de réduire davantage les coûts des utilisateurs, et nous prévoyons de publier prochainement la prise en charge binaire de jina-embeddings-v4.