LLM plus légers : comment réduire un modèle d'IA sans perdre en puissance

Imaginez passer trois semaines à entraîner un modèle d'intelligence artificielle parfait. Vous obtenez enfin les résultats attendus. et vous réalisez que votre modèle pèse 140 Go. Résultat : il faut quatre cartes graphiques haut de gamme pour le faire tourner, soit un budget de 80 000 à 100 000 dollars. Ce scénario est plus courant qu'on ne le pense, et il est pourtant évitable.

Un modèle d'IA n'a pas besoin d'être stocké dans sa version la plus lourde pour fonctionner correctement. Deux techniques permettent de le rendre plus léger : la quantification et l'élagage. Elles sont souvent confondues, mais elles résolvent des problèmes différents et peuvent même être utilisées ensemble.

QUANTIFICATION : RÉDUIRE LA TAILLE DES NOMBRES SANS TOUCHER AU MODÈLE

La quantification consiste à remplacer les nombres à virgule flottante de 16 bits (comme 0,0023847) par des entiers sur 4 bits ou 8 bits. Le nombre de paramètres du modèle reste identique, mais chaque poids occupe moins de place en mémoire et les calculs sont plus rapides. C'est comme si vous enregistriez une photo en haute résolution mais en réduisant sa profondeur de couleur : tous les éléments sont toujours visibles, mais avec moins de nuances.

Cette technique ne supprime aucun paramètre, elle réduit simplement la précision des calculs. Résultat : le modèle prend moins de place et s'exécute plus vite, sans perdre ses capacités principales. La quantification est particulièrement utile pour les modèles très grands, comme ceux contenant 70 milliards de paramètres, qui passent de 140 Go à environ 35-40 Go en version 4 bits.

ÉLAGAGE : SUPPRIMER CE QUI NE SERT À RIEN

L'élagage, à l'inverse, supprime carrément des connexions entre neurones, des têtes d'attention ou même des couches entières du modèle. C'est comme si vous éditiez un long document en supprimant les phrases inutiles plutôt que de simplement réduire la taille de la police. Le nombre total de paramètres diminue, ce qui rend le modèle plus léger et plus rapide.

Les deux techniques réduisent la taille d'un modèle, mais pas de la même manière. La quantification agit sur la précision des calculs, tandis que l'élagage supprime des éléments inutiles. Elles peuvent être combinées pour obtenir un modèle encore plus léger.

POURQUOI C'EST CRUCIAL DE COMPRESSER SES MODÈLES ?

Ne pas compresser un modèle a un coût réel. D'abord, le matériel nécessaire devient extrêmement cher : un modèle de 70 milliards de paramètres en FP16 nécessite quatre cartes graphiques A100 pour fonctionner, soit un investissement de 80 000 à 100 000 dollars avant même de pouvoir l'utiliser. Ensuite, la latence augmente : plus le modèle est lourd, plus les calculs prennent du temps, ce qui rend impossible l'utilisation dans des applications nécessitant une réponse rapide, comme un chatbot en direct ou un assistant vocal.

Mais compresser un modèle trop agressivement a aussi des risques. Une quantification trop poussée ou un élagage mal réalisé peut dégrader les performances du modèle de manière invisible. Par exemple, une étude de Red Hat portant sur plus de 500 000 évaluations de modèles quantifiés a montré que la perte de qualité varie énormément selon le modèle, la tâche et la méthode utilisée. Certains modèles supportent une compression agressive sans problème, tandis que d'autres s'effondrent rapidement. La seule façon de savoir si un modèle compressé fonctionne bien est de le tester sur des tâches réelles, pas seulement de vérifier qu'il produit des phrases grammaticalement correctes.

LES CINQ MÉTHODES POUR COMPRESSER UN MODÈLE EN PRODUCTION

Voici cinq méthodes concrètes, testées et utilisées en production aujourd'hui. Trois concernent la quantification, deux l'élagage. Elles diffèrent par leur complexité d'utilisation et leurs objectifs.

1. BITSANDBYTES (NF4) : LA QUANTIFICATION SIMPLE ET PUISSANTE

Cette méthode est souvent la première à essayer, car elle est simple à mettre en œuvre. Elle utilise un type de données appelé NF4 (NormalFloat4), spécialement conçu pour les réseaux de neurones. Les poids d'un réseau de neurones suivent généralement une distribution normale (en forme de cloche), et non une répartition uniforme. Le NF4 place les valeurs disponibles sur 4 bits là où se trouvent réellement les poids, plutôt que de les répartir uniformément sur toute la plage.

Un autre avantage majeur : cette méthode supporte QLoRA, ce qui permet de charger un modèle en 4 bits et de l'entraîner ensuite en ajoutant de petits adaptateurs légers, sans toucher aux poids de base en 4 bits. Si vous prévoyez de faire du fine-tuning, c'est la méthode idéale pour commencer.

from transformers import AutoModelForCausalLM, AutoTokenizer, BitsAndBytesConfig\nimport torch\n\nmodelid = \"meta-llama/Llama-3.1-8B-Instruct\"\n\n# Configuration de la quantification 4 bits avec double quantification\nbnbconfig = BitsAndBytesConfig(\n    loadin4bit=True,                      # charge les poids en 4 bits au lieu de 16 bits\n    bnb4bitquanttype=\"nf4\",              # NormalFloat4 : un type de données adapté\n                                           # à la distribution normale des poids\n    bnb4bitcomputedtype=torch.bfloat16,  # les calculs sont montés en bfloat16\n                                           # pendant l'exécution, les poids restent en 4 bits\n    bnb4bitusedoublequant=True,         # quantifie aussi les constantes de quantification\n                                           # économisant environ 0,4 bits par paramètre\n)\n\ntokenizer = AutoTokenizer.frompretrained(modelid)\nmodel = AutoModelForCausalLM.frompretrained(\n    modelid,\n    quantizationconfig=bnbconfig,\n    devicemap=\"auto\",                       # répartit les couches sur les GPU disponibles\n                                            # décharge sur le CPU si nécessaire\n)\n\ninputs = tokenizer(\"Explique la quantification en une phrase.\", returntensors=\"pt\").to(model.device)\noutput = model.generate(**inputs, maxnewtokens=40)\nprint(tokenizer.decode(output[0], skipspecialtokens=True))

Dans ce code, loadin4bit=True active la quantification 4 bits directement lors du chargement du modèle, sans étape de quantification séparée. bnb4bitquant_type=\"nf4\" choisit le format adapté à la distribution normale des poids, ce qui préserve la qualité du modèle. bnb4bitcompute_dtype=torch.bfloat16 indique que les calculs sont temporairement montés en bfloat16 pendant les multiplications matricielles, car les GPU n'ont pas encore de noyaux natifs pour le calcul 4 bits. Enfin, bnb4bitusedoublequant=True quantifie aussi les constantes de quantification, économisant un peu plus de mémoire sans perte de précision.

2. GPTQ : LA QUANTIFICATION AVEC CORRECTION D'ERREUR

GPTQ est l'une des premières méthodes de quantification 4 bits à avoir fonctionné correctement sur de grands modèles. Elle a été introduite dans un article de 2022 par Frantar et ses collègues. Contrairement à une quantification naïve qui arrondit chaque poids indépendamment, GPTQ quantifie couche par couche et utilise des informations de second ordre (une approximation de la matrice Hessienne) pour déterminer comment l'arrondi d'un poids affecte les poids voisins. Elle ajuste ensuite les poids restants dans la couche pour compenser l'erreur introduite. C'est une correction d'erreur intégrée directement dans le processus de quantification.

Cette méthode nécessite un jeu de données de calibration, généralement quelques centaines d'échantillons de texte représentatif, pour estimer précisément les statistiques de la Hessienne.

from transformers import AutoModelForCausalLM, AutoTokenizer, GPTQConfig\nimport torch\n\nmodelid = \"meta-llama/Llama-3.1-8B-Instruct\"\ntokenizer = AutoTokenizer.frompretrained(modelid)\n\n# GPTQConfig gère à la fois la calibration et la quantification en une seule passe\ngptqconfig = GPTQConfig(\n    bits=4,                      # largeur de bits cible par poids\n    dataset=\"c4\",                 # texte de calibration utilisé pour estimer\n                                  # la compensation d'erreur basée sur la Hessienne\n    tokenizer=tokenizer,\n    groupsize=128,               # les poids sont quantifiés par groupes de 128,\n                                  # équilibrant précision et taux de compression\n    descact=False,               # ignore la permutation d'ordre des activations\n                                  # pour une inférence plus rapide, au prix d'une légère perte de précision\n)\n\nmodel = AutoModelForCausalLM.frompretrained(\n    modelid,\n    quantizationconfig=gptqconfig,\n    devicemap=\"auto\",\n    torchdtype=torch.float16,\n)\n\nmodel.savepretrained(\"./llama-3.1-8b-gptq-int4\")\ntokenizer.savepretrained(\"./llama-3.1-8b-gptq-int4\")

Dans ce code, dataset=\"c4\" est crucial : c'est le texte sur lequel le modèle effectue des passes avant pour collecter les statistiques d'activation dont GPTQ a besoin pour calculer sa correction d'erreur couche par couche. group_size=128 contrôle la granularité de la quantification : des groupes plus petits signifient plus de constantes de mise à l'échelle stockées (un peu plus de mémoire) en échange d'une précision plus élevée. desc_act=False désactive une étape de réordonnancement qui traite d'abord les colonnes de poids les plus impactantes, ce qui améliore légèrement la précision mais ralentit à la fois la quantification et l'inférence dans certains environnements de production.

En janvier 2026, un benchmark de Jarvis Labs comparant les quatre principaux formats 4 bits sur le même matériel a montré que GPTQ était moins performant sur les tâches de génération de code, avec un score d'environ 46 % sur HumanEval, contre 51,8 % pour AWQ et GGUF. La cause probable est que l'erreur de propagation colonne par colonne de GPTQ s'accumule davantage au fil des multiplications matricielles, ce qui pénalise les tâches de raisonnement multi-étapes comme l'écriture de code correct.

3. AWQ : PROTÉGER LES POIDS IMPORTANTS PENDANT LA QUANTIFICATION

AWQ, introduit dans un article de Lin et ses collègues en 2023, adopte une approche différente. Au lieu de corriger l'erreur après coup comme le fait GPTQ, AWQ commence par identifier les poids les plus importants. Pendant une courte passe de calibration, il observe les activations et repère les canaux de poids qui produisent systématiquement les magnitudes d'activation les plus élevées. Ces poids