Inférence LLM 1,6× plus rapide — et 13 % de qualité en plus : nos recherches ASVD + LoRA
Nous avons mené 8 expériences de compression de GPT-2 Large avec ASVD et récupération LoRA. Résultat : 1,6× d'accélération à l'inférence tout en surpassant le modèle d'origine de 13 %. Voici ce que nous avons appris et pourquoi ça change les choses pour le déploiement IA en entreprise.
Mohamed est Expert Ingénieur IA chez Brainum, spécialisé dans la conception de systèmes agentiques, les pipelines RAG et le déploiement de solutions d'IA en production. Il accompagne les organisations dans leur transformation IA depuis plus de 10 ans.
LinkedInFaire tourner des grands modèles de langage en production coûte cher. Pas les entraîner — les faire tourner. Chaque token généré sur un endpoint utilisateur correspond à des multiplications matricielles sur des tenseurs de poids denses. À l'échelle, ce coût domine tout le reste.
Les réponses standard sont la quantification (4-bit, 8-bit), la distillation (entraîner un modèle plus petit) ou simplement du matériel plus puissant. Nous avons voulu explorer une voie moins balisée : approcher les matrices de poids elles-mêmes par des factorisations structurées — et récupérer la qualité avec un fine-tuning léger.
Cet article documente huit expériences menées sur ce problème, des matrices jouets à un pipeline fonctionnel sur GPT-2 Large qui atteint 1,6× d'accélération à l'inférence avec une perplexité de 0,863× la baseline — un modèle à la fois plus rapide et meilleur que l'original.
L'idée centrale
Une couche MLP de transformeur calcule :
Y = σ(W · X) où W: (out × in), X: (in × N)
La multiplication matricielle complète coûte out × in opérations par token. Si on approche W par un produit de deux matrices plus petites :
W ≈ A · B A: (out × k), B: (k × in), k << min(out, in)
le coût passe à (out + in) × k. L'accélération théorique est :
speedup = (out × in) / ((out + in) × k)
La condition de rentabilité — speedup > 1 — exige k < in_dim / 2. Pour un modèle 1280-dim comme GPT-2 Large, le rang de rentabilité est 640.
La question est de savoir si, à rang=640, l'approximation est suffisamment précise pour être utile — et si une récupération légère peut la rendre assez précise.
Vue d'ensemble des expériences
| # | Méthode | Modèle | Résultat clé |
|---|---|---|---|
| 01 | SVD + gate binaire | 128×128 aléatoire | Erreur de 0,25 → 0,90 sur 12 couches ; gate binaire ≡ ReLU, aucune accélération |
| 02 | SVD naïf | GPT-2 small | Poids denses ; zones qualité et vitesse jamais en intersection |
| 03 | ASVD | GPT-2 small | 8–9× mieux que SVD naïf ; couche 0 bloquante |
| 04 | Monarch | GPT-2 small | 3× mieux que SVD à budget égal ; toutes les méthodes échouent à cette échelle |
| 05 | ASVD | GPT-2 Large | Premier succès : 1,6× speedup à 2,78× ppl ; aucune couche bloquante |
| 06 | ASVD + LoRA (zero-init) | GPT-2 Large | Pipeline complet : 0,89× baseline, 1,6× speedup, 1,13% paramètres entraînables |
| 07 | ASVD + correction forme fermée | GPT-2 Large | Échec : 4,54× ppl vs 0,89× pour LoRA ; cascade inter-couches nécessite les gradients |
| 08 | ASVD + LoRA (CF-init) | GPT-2 Large | Meilleur résultat : 0,863× baseline, epoch 1 seule dépasse le final Exp 06 |
Pourquoi le SVD naïf ne fonctionne pas
La première expérience sur de vrais poids (Exp 02) a été la plus instructive. Le SVD donne l'approximation rang-k théoriquement optimale de toute matrice au sens de la norme de Frobenius — c'est l'outil idéal en théorie. Nous l'avons appliqué aux couches MLP de GPT-2 small et mesuré la perplexité.
Résultat :
| Rang | % du dense | PPL | ×baseline |
|---|---|---|---|
| 256 | 22,2 % | 600+ | ~23× |
| 512 | 44,4 % | 293 | ~10× |
| 768 | 66,7 % | 35–50 | ~2× |
L'accélération GPU n'apparaît qu'à rang ≤ 256 — mais à rang ≤ 256 le modèle est complètement cassé. La zone de vitesse et la zone de qualité ne se croisent jamais.
La raison : les poids de GPT-2 ne sont pas à rang faible. L'analyse du spectre singulier de chaque couche montre que 39–67 % du rang complet est nécessaire pour capturer 90 % de l'énergie. Les poids utilisent presque toutes leurs dimensions. Le SVD naïf, qui minimise l'erreur de reconstruction des poids, ne sait pas quelles directions importent le plus pour les sorties réelles.
ASVD : la correction indispensable
L'idée clé derrière l'ASVD (Activation-Aware SVD) est que ce qui compte n'est pas la proximité entre W_approx et W dans l'espace des poids — c'est la proximité entre W_approx · X et W · X sur des entrées réelles.
Certains canaux d'entrée portent beaucoup plus d'énergie d'activation que d'autres. Si le canal j est systématiquement grand dans les entrées réelles, une erreur dans cette colonne de W se propagera en grandes erreurs de sortie. Si le canal j est presque toujours proche de zéro, son erreur de reconstruction est sans importance.
L'ASVD corrige cela en pondérant les colonnes des poids par les statistiques d'activation par canal avant le SVD :
s_j = mean|X_j|^α (jeu de calibration, α=0,5)
W_scaled = W · diag(s) (amplifier les canaux importants)
W_approx = SVD_k(W_scaled) / diag(s) (dé-scaler après)
À rang égal, l'amélioration de qualité par rapport au SVD naïf est spectaculaire :
| Rang | SVD naïf PPL | ASVD PPL | Gain |
|---|---|---|---|
| 384 | 601 | 64 | 9× mieux |
| 512 | 293 | 34 | 8× mieux |
L'ASVD n'est pas une amélioration marginale. C'est la différence entre un modèle cassé et un modèle utilisable. Toutes les expériences suivantes ont utilisé exclusivement l'ASVD — le SVD naïf n'est pas une option viable sur des poids LLM réels.
Pourquoi la taille du modèle est le facteur déterminant
Après quatre expériences sur GPT-2 small (matrices 768-dim), le constat était clair : les méthodes fonctionnent mathématiquement, mais le rang de rentabilité (< 384) est exactement le seuil où la qualité s'effondre. Aucune méthode testée ne parvenait à être simultanément rapide et précise à l'échelle de GPT-2 small.
La solution était simplement d'utiliser un modèle plus grand.
GPT-2 Large (matrices 1280-dim) a un rang de rentabilité de 640. À rang=640 :
| Méthode | PPL | ×baseline | Speedup |
|---|---|---|---|
| Baseline dense | 16,50 | 1,0× | 1,0× |
| SVD naïf rang=640 | ~1554 | 94× | 1,6× |
| ASVD rang=640 | 45,9 | 2,78× | 1,6× |
Pour la première fois, les zones se croisent : 1,6× d'accélération pour seulement 2,78× de dégradation de perplexité. Cette dégradation est significative mais potentiellement récupérable.
L'analyse de sensibilité par couche a été le diagnostic critique : comprimer chaque couche individuellement (toutes les autres restant denses) montre que chaque couche tolère rang=640 dans une limite de ±2 % de la baseline. Aucune couche n'est un point de blocage. La dégradation globale de 2,78× est le cumul de 36 petites erreurs — pas un dommage structurel sur une couche spécifique. Cette distinction est fondamentale pour la suite.
Récupération LoRA : compressé + récupéré > original
Sachant que les dommages par couche sont petits et additifs, nous avons ajouté des adaptateurs LoRA (Low-Rank Adaptation) sur les poids compressés et fine-tuné sur WikiText-2.
Configuration :
- ASVD rang=640 appliqué à toutes les couches MLP et de projection d'attention (36 couches × 3 matrices)
- Adaptateurs LoRA rang=16 sur les poids compressés gelés
- Paramètres entraînables : 1,13 % du total
- Entraînement : 3 epochs, WikiText-2, AdamW, ~55 minutes sur un GPU T4 (0,55 $ au total)
Les résultats ont été frappants :
| Étape | PPL | ×baseline | Temps |
|---|---|---|---|
| Baseline dense | 27,56 | 1,000× | — |
| ASVD rang=640 | 153,82 | 5,58× | — |
| + LoRA epoch 1 | 25,57 | 0,93× | 18 min |
| + LoRA epoch 2 | 24,70 | 0,90× | 37 min |
| + LoRA epoch 3 | 24,53 | 0,89× | 55 min |
Dès l'epoch 1 — après seulement 18 minutes d'entraînement — le modèle compressé surpasse déjà la baseline non compressée. Résultat final après 3 epochs : 0,89× perplexité baseline avec 1,6× speedup d'inférence entièrement préservé.
Les adaptateurs LoRA ne sont pas nécessaires à l'inférence. Le déploiement final utilise uniquement les poids factorisés A · B — l'accélération de 1,6× est structurelle, indépendante de tout artefact d'entraînement.
Pourquoi 75 % de la récupération se fait dans les 300 premières étapes ? Parce que la correction nécessaire par couche est petite (±2 %). Les 1,13 % de paramètres entraînables n'apprennent pas une nouvelle tâche — ils défont de petites erreurs systématiques simultanément sur 36 couches. Une fois que chaque adaptateur trouve sa direction cible, la convergence est rapide.
Le piège de la correction forme fermée (Expérience 07)
Une question naturelle après l'Expérience 06 : a-t-on vraiment besoin d'un entraînement gradient ? La décomposition ASVD nous donne déjà les vecteurs singuliers abandonnés à rang=640. Ne peut-on pas simplement utiliser les 16 vecteurs singuliers suivants (640:656) comme correction directe en forme fermée ?
Nous l'avons testé. Résultat avec correction rang=16 en forme fermée : 4,54× baseline — cinq fois pire que LoRA à budget de paramètres identique.
La raison est la cascade inter-couches. La correction de chaque couche est calculée en supposant les bonnes entrées — les activations du prédécesseur ASVD-compressé. Mais une fois la couche 0 corrigée, sa sortie change, et la correction de la couche 1 avait été calibrée sur la sortie non corrigée. Trente-six corrections individuellement correctes ne s'additionnent pas ; elles font des hypothèses mutuellement incohérentes sur les sorties les unes des autres.
La correction en forme fermée par couche nécessite le flux de gradient bout-en-bout pour fonctionner. On ne peut pas corriger chaque couche isolément et espérer que la séquence de corrections soit mutuellement cohérente. Le fine-tuning LoRA fournit exactement cela — chaque mise à jour d'adaptateur prend en compte tous les autres adaptateurs, via la rétropropagation.
Initialisation style LoftQ : le meilleur des deux mondes (Expérience 08)
L'échec de l'Expérience 07 pointait vers quelque chose d'important : la correction en forme fermée échoue seule, mais identifie le bon sous-espace. Les vecteurs singuliers [640:656] sont les composantes principales de l'erreur ASVD. Un LoRA entraîné depuis zéro doit découvrir ces directions par descente de gradient sur plusieurs epochs.
Et si on les donnait directement à l'optimiseur dès le départ ?
C'est l'intuition de LoftQ (arXiv:2310.08659), développée à l'origine pour la récupération après quantification : initialiser les adaptateurs LoRA depuis le SVD du résidu de quantification. Appliqué à l'ASVD (qui est linéaire, donc sans itérations alternées nécessaires), l'initialisation est exacte :
# Depuis la décomposition ASVD U, Σ, Vh :
lora_A.weight = B_init · sqrt(r/alpha)
lora_B.weight = A_init · sqrt(r/alpha)
# où A_init = U[:, k:k+r] (r vecteurs singuliers suivants)
# B_init = Σ[k:k+r] * Vh[k:k+r] / s (dé-scalés)
À l'initialisation (t=0), la correction LoRA vaut exactement A_init · B_init — la meilleure correction rang-r possible en forme fermée du résidu ASVD. À partir de là, le fine-tuning conjoint résout les incohérences inter-couches que l'initialisation par couche seule ne peut pas gérer.
Résultats vs LoRA zero-init :
| Epoch | CF-init PPL | Zero-init PPL | Avantage CF |
|---|---|---|---|
| 1 | 24,64 | 25,57 | −0,93 ppl |
| 2 | 23,85 | 24,70 | −0,85 ppl |
| 3 | 23,79 | 24,53 | −0,74 ppl final |
L'epoch 1 de CF-init (24,64) surpasse déjà trois epochs complètes de zero-init (24,53). L'écart ne se ferme pas à l'epoch 3 — les optima finaux sont genuinement différents. Le démarrage à chaud ne converge pas seulement plus vite ; il trouve un meilleur basin.
Surcoût : ~38 secondes de calcul SVD supplémentaire avant l'entraînement. Retour : 3 % de meilleure qualité finale à coût d'entraînement identique.
Résultat final : 23,79 ppl — 0,863× baseline, 1,6× speedup d'inférence.
Le pipeline complet
Le pipeline complet qui fonctionne, validé bout-en-bout sur GPT-2 Large :
1. Calibration (~10 secondes)
Faire passer ~260 tokens dans le modèle, collecter les statistiques d'activation par canal : s_j = mean|X_j|^0,5
2. Compression ASVD (~20 secondes, une seule fois, hors-ligne)
Pour chaque couche cible : scaler les colonnes par s, lancer le SVD, tronquer à rang=640, dé-scaler. Stocker sous forme factorisée (A, B) pour l'inférence.
3. Initialisation LoRA en forme fermée (~38 secondes, une seule fois) Depuis le même SVD : extraire les 16 prochains vecteurs singuliers comme correction résiduelle. Initialiser les adaptateurs LoRA à la meilleure correction rang-16 possible de l'erreur ASVD.
4. Fine-tuning LoRA (~18 minutes sur T4, 1 epoch est suffisant) Poids compressés gelés + adaptateurs LoRA rang=16. 1,13 % de paramètres entraînables. Fine-tuning sur des données pertinentes pour le domaine cible.
5. Inférence
Utiliser uniquement les poids factorisés : y = x @ B.T @ A.T. Les adaptateurs LoRA peuvent être fusionnés ou abandonnés. L'accélération de 1,6× est entièrement préservée.
Coût total d'optimisation : ~1 heure sur GPU T4 à 0,59 $/h. Résultat net : inférence 1,6× plus rapide, perplexité 13,7 % meilleure que le modèle dense d'origine.
Leçons clés pour les praticiens
1. Les grands modèles sont intrinsèquement plus compressibles.
Le rang de rentabilité évolue avec in_dim. GPT-2 small (768-dim) ne peut pas être compressé de façon rentable avec des méthodes bas-rang. GPT-2 Large (1280-dim) le peut. LLaMA-7B (4096-dim) devrait l'être encore plus — à même ratio de compression, il y a plus de marge avant d'atteindre le plancher de qualité.
2. ASVD plutôt que SVD naïf, toujours. À budget de rang identique, l'ASVD est 8–34× meilleur en perplexité sur des poids LLM réels. Le SVD naïf minimise l'erreur de reconstruction des poids, ce qui est le mauvais objectif. Minimisez toujours l'erreur de sortie sur des entrées réelles.
3. Analyser la sensibilité par couche avant toute récupération. Avant de fine-tuner un modèle compressé, tester chaque couche individuellement. Si une couche est catastrophiquement sensible (comme la couche 0 dans GPT-2 small), le fine-tuning ne peut pas la récupérer — l'information est perdue. Si toutes les couches sont individuellement tolérantes (comme dans GPT-2 Large), les dommages globaux sont additifs et entièrement récupérables.
4. 1 epoch de LoRA est souvent suffisant. 75 % de la récupération de qualité se produit dès la première epoch. Le modèle ne apprend pas une nouvelle tâche ; il corrige de petites erreurs systématiques. Pour les décisions de déploiement, lancer 1 epoch plus une évaluation est une meilleure utilisation du compute que 3 epochs.
5. L'initialisation en forme fermée est une amélioration gratuite de 3 %. Le SVD du résidu ASVD prend 38 secondes et donne 3 % de meilleure qualité finale à coût d'entraînement identique. Il n'y a aucune raison d'initialiser LoRA à zéro après une compression ASVD. Utilisez toujours l'initialisation SVD résiduelle.
Ce que cela signifie pour l'IA en entreprise
L'implication n'est pas que vous devriez compresser GPT-2 Large — c'est que vous devriez compresser les grands modèles que vous faites tourner réellement en production.
Le même pipeline appliqué à un LLaMA-7B ou un Mistral-7B donnerait :
- Rang de rentabilité : < 2048 (sur des matrices 4096-dim)
- Accélération théorique à rang=2048 : 2,0×
- Coût de fine-tuning : comparable (~1 heure sur A100, chargement 4-bit dans ~4 Go de VRAM)
- Récupération ciblée sur le domaine : l'étape LoRA peut utiliser votre propre corpus de production
Une accélération d'inférence de 1,6–2× à même niveau de qualité n'est pas un résultat académique. Sur un endpoint servant des millions de requêtes par jour, cela divise par deux le coût GPU — sans changement matériel, sans artefacts de quantification, sans modification de l'architecture du modèle.
Le coût d'optimisation ponctuel (< 1 heure) est négligeable face aux coûts d'inférence continus. L'investissement est amorti dans les premières heures de trafic en production.
Questions fréquentes
Qu'est-ce que l'ASVD (Activation-Aware SVD) ? L'ASVD est une technique de compression des matrices de poids de réseaux de neurones via SVD qui minimise l'erreur sur les sorties réelles du modèle plutôt que sur les poids eux-mêmes. Elle pondère chaque colonne de poids par la magnitude d'activation moyenne du canal d'entrée correspondant avant la décomposition, garantissant que les canaux à forte activation reçoivent une représentation plus précise dans l'approximation bas-rang. Elle surpasse systématiquement le SVD naïf de 8–34× sur la perplexité des LLM à même ratio de compression.
La compression d'un LLM réduit-elle toujours sa qualité ? Pas nécessairement. Associée à un fine-tuning LoRA (récupération post-compression), un modèle compressé peut surpasser la baseline originale. Dans nos expériences, la compression ASVD rang=640 suivie d'un fine-tuning LoRA (1,13 % de paramètres entraînables, 55 minutes sur un GPU T4) a atteint 0,863× la perplexité baseline — 13,7 % mieux que le modèle non compressé — tout en maintenant 1,6× d'accélération d'inférence.
Quelle est la différence entre ASVD et LoftQ ? LoftQ (Low-Rank + Quantization) utilise le SVD du résidu de quantification pour initialiser les adaptateurs LoRA avant le fine-tuning, et applique des itérations alternées quantification + SVD parce que la quantification est non linéaire. L'ASVD est une technique de factorisation bas-rang avec prise en compte des activations. Dans nos travaux, nous combinons les deux idées : compression ASVD suivie d'une initialisation SVD résiduel style LoftQ pour LoRA — mais sans l'alternance itérative de LoftQ, car la factorisation linéaire de l'ASVD admet une décomposition résiduelle optimale en une seule passe.
Pourquoi la correction en forme fermée par couche échoue-t-elle quand le fine-tuning LoRA réussit ? La correction par couche suppose que les entrées de chaque couche sont inchangées — mais corriger la couche N modifie sa sortie, invalidant la correction calculée pour la couche N+1. Les 36 corrections font des hypothèses mutuellement incohérentes. Le fine-tuning LoRA résout cela via la rétropropagation bout-en-bout : chaque mise à jour d'adaptateur prend en compte tous les autres adaptateurs, donc les corrections deviennent mutuellement cohérentes au fil de l'entraînement.
Quels modèles bénéficient le plus de cette approche ?
Les modèles avec de plus grandes dimensions cachées bénéficient davantage. La condition de rentabilité exige un rang de compression k < in_dim / 2. Les grands modèles satisfont cette condition à des valeurs de rang absolu plus élevées, ce qui signifie qu'une plus grande partie de l'information du modèle peut être conservée au point de rentabilité. LLaMA-7B (4096-dim), Mistral-7B (4096-dim), et tout grand modèle moderne devraient voir de meilleurs résultats que GPT-2 Large (1280-dim).
Nous appliquons activement cette recherche à des déploiements LLM en production. Si vous gérez des charges de travail IA intensives en inférence et souhaitez discuter des stratégies de compression adaptées à votre architecture, parlons-en.
Cet article vous a inspiré ?
Parlons de vos enjeux IA lors d'un appel découverte.
Réserver un appel