TurboQuant : un cache KV pour LLM 6 fois plus petit sans perte de précision
Dans la génération de modèles linguistiques autoregressifs, le mécanisme d'attention repose sur les vecteurs Clé et Valeur des tokens précédents. Recalculer le contexte complet à chaque étape est inefficace, d'où l'utilisation de caches pour les représentations intermédiaires. Le cache KV croît linéairement avec la longueur du contexte, ce qui limite le débit et la taille maximale du contexte.
Sur des séquences longues, l'inférence atteint les limites de bande passante mémoire : les GPU passent plus de temps à lire les données qu'à calculer. Cela augmente la latence et les coûts. TurboQuant résout cela en compressant le cache tout en préservant le sens sémantique nécessaire à l'attention.
Comment fonctionne PolarQuant
La première étape est PolarQuant. Les vecteurs sont transformés en coordonnées polaires après une rotation aléatoire. Le rayon encode l'amplitude du vecteur, l'angle capte sa direction.
# Pseudocode : PolarQuant
rotated = rotate_random(vector)
rho = norm(rotated) # rayon
phi = angle(rotated) # angle
quantized = quantize(rho, phi)La rotation aléatoire simplifie la distribution des données, la rendant prévisible pour la quantification. Aucun paramètre supplémentaire ni codebook nécessaire — la compression atteint 3 à 4 bits par valeur sans ajuster le modèle.
Correction d'erreur via QJL
La quantification introduit du bruit. La deuxième étape est QJL (Johnson-Lindenstrauss quantifié), qui encode l'erreur résiduelle en seulement 1 bit par valeur. La transformation préserve les distances euclidiennes entre vecteurs — essentiel pour l'attention par produit scalaire.
QJL approxime le lemme de Johnson-Lindenstrauss sous forme quantifiée :
- Entrée : erreur résiduelle après PolarQuant
- Sortie : correction de 1 bit
- Propriété : ||Qx - Qy|| ≈ ||x - y|| pour x, y ∈ cache KV
Ensemble, ils atteignent 1,25 à 2 bits par valeur avec une dégradation négligeable de la perplexité.
Benchmarks et performances
Testé sur Llama-3.1-8B-Instruct (LongBench) :
- Compression : 6 à 8x par rapport à la base
- Accélération du calcul des logits : jusqu’à 8x sur H100 (base JAX)
- Qualité : moins de 1 % de chute sur les tâches "needle-in-haystack" et contextes longs
Sur GloVe (d=200), TurboQuant excelle dans le compromis entre rappel et ratio de compression (optimal à 1:k).
| Méthode | Bits/valeur | Compression | Chute de perplexité |
|--------|------------|-------------|----------------------|
| Base | 16 | 1x | 0 % |
| INT8 | 8 | 2x | 0,5 % |
| TurboQuant (3 bits) | 3 | 6x | 0,2 % |
Atteint jusqu’à 3 bits sans re-entraînement — une percée pour la quantification zéro-shot.
Points clés
- Compression extrême : réduction du cache KV de 6x à 3 bits par valeur.
- Inférence plus rapide : accélération jusqu’à 8x sur les charges mémoire intensives.
- Préservation des distances : QJL garantit la compatibilité avec l’attention.
- Applicabilité universelle : fonctionne pour la recherche vectorielle et le RAG.
- Pas besoin d’ajustement : remplacement plug-and-play pour les LLM existants.
Au-delà des LLM
TurboQuant va au-delà des architectures transformer. Dans les bases de données vectorielles, la compression des embeddings maintient les performances de recherche ANN (HNSW, FAISS). Sur les dispositifs embarqués, elle réduit la charge DRAM, permettant l’inférence locale.
Pour les ingénieurs seniors : intégrez-le dans vos moteurs d’inférence personnalisés. Le support JAX/Flax simplifie la prototypage. Testez sur des contextes longs (>128k tokens) pour libérer des gains concrets.
— Editorial Team
Aucun commentaire pour le moment.