Quantification LLM : Modèle 160GB sur un ordinateur portable

Quantification des LLM : exécuter des modèles de 160 Go sur un ordinateur portable avec une perte minimale

Des modèles comme Qwen-3-Coder-Next, dotés de 80 milliards de paramètres, occupent jusqu'à 159,4 Go de mémoire. La quantification réduit la taille du modèle de 4 fois et accélère l'inférence de 2 fois, tout en causant une baisse de qualité de seulement 5 à 10 %. Cela rend possible l'exécution de grands LLM sur du matériel grand public sans sacrifier les performances.

Paramètres et leur impact sur la taille du modèle

Les paramètres — poids dans un réseau neuronal — déterminent la consommation mémoire d'un LLM. Chaque paramètre est stocké sous forme de nombre à virgule flottante. L'unité la plus simple : l'entrée multipliée par le poids donne la sortie. Les vrais modèles comptent des centaines de couches avec des milliers de nœuds, entraînant des milliards de paramètres.

Par exemple, un réseau avec 2 entrées, 3 couches de 4 nœuds chacune et 2 sorties possède 64 paramètres. En échelle, avec des centaines de milliers de nœuds, on atteint des billions de poids. Les histogrammes des modèles populaires montrent que 99 % des valeurs sont proches de zéro, dans la plage [-0,5 ; 0,5].

Représentation des nombres en mémoire

Les ordinateurs stockent les float32 : 1 bit de signe, 8 bits d'exposant, 23 bits de mantisse. Plage ±3,4×10³⁸ avec 7 chiffres significatifs. La répartition est inégale — plus dense près de zéro, plus clairsemée aux extrêmes. Cela convient parfaitement aux LLM, où les poids sont petits.

Float16 : 1+5+10 bits, précision de 3 à 4 chiffres, plage ±65 504. Bfloat16 (1+8+7) : large plage, 2 à 3 chiffres. Float8/Float4 sont expérimentaux, avec 3 à 4 bits de mantisse.

Approximation d'une onde sinusoïdale : float32 est lisse ; float4 est en escalier, avec des erreurs visibles.

Principes de la quantification

La quantification est une compression avec perte : mapper les flottants vers un ensemble de valeurs plus petit. Un arrondi simple (arrondi au plus proche) de bfloat16 vers float4 casse le modèle : les poids deviennent zéro, la sortie est nulle. Pourquoi ? La plage de float4 [-3,3] ne correspond pas aux poids typiques [-0,89,0,16].

Quantification symétrique

Échelonner les données dans des plages entières. Formule : échelle = vmax / (2^(bits - 1) - 1). Quantifier : round(valeur / échelle), déquantifier : quantifié * échelle.

Exemple de code en JavaScript :

function quantize({ values, bits }) {
  const vmax = Math.max(...values.map(Math.abs));
  const qmax = 2 ** (bits - 1) - 1;
  const scale = vmax / qmax;
  return {
    values: values.map((v) => Math.round(v / scale)),
    scale,
  };
}

function dequantize({ values, scale }) {
  return values.map((v) => v * scale);
}

Pour les valeurs = [-0,89, 0,16, 0,08, -0,13, 0,16, -0,54], bits = 4 :

• quantifié : [-7, 1, 1, -1, 1, -4], échelle ≈ 0,127
• déquantifié : [-0,89, 0,127, 0,127, -0,127, 0,127, -0,509]
• erreur moyenne : 18 %

Sortie du modèle après quantification 4 bits : écart de 30 % par rapport à l’original, mais empreinte mémoire divisée par 4.

Quantification asymétrique

Améliore la quantification symétrique en traitant min/max séparément. Intervalle [min, max] est mappé sur [qmin, qmax]. Formule :

• offset = min
• scale = (max - min) / (qmax - qmin)
• quantized = round((value - offset) / scale)

Cela utilise efficacement l’espace : pour des données déséquilibrées (plus de valeurs négatives), le côté positif n’est pas gaspillé. L’erreur moyenne tombe à 5–10 %.

Appliquer aux tenseurs : quantifier par canal ou par groupe (quantification par groupe) pour minimiser les erreurs d’activation.

Évaluation de la qualité après quantification

Mesurer le perplexité sur un jeu de validation ou des métriques spécifiques à la tâche (BLEU, ROUGE). Benchmarks :

• Qwen-3-Coder-Next 4 bits : +7 % de perplexité vs FP16
• Vitesse : x2 sur GPU sans coeurs tensoriels

| Format | Taille (Go) | Perplexité | Vitesse (tokens/sec) |

|--------|-------------|------------|-----------------------|

| FP16 | 159,4 | 1,00 | 1,0 |

| INT8 | 39,8 | 1,05 | 1,8 |

| INT4 | 19,9 | 1,09 | 2,1 |

Points clés

• La quantification réduit la taille du modèle de 4 à 8 fois sans re-entraînement.
• Utilisez la quantification symétrique pour des données symétriques ; asymétrique pour des distributions déséquilibrées.
• La quantification par groupe (groupes de 128 éléments) équilibre précision et vitesse.
• Prise en charge directe dans llama.cpp, bitsandbytes : INT4/INT8.
• Testez sur des tâches cibles : programmation, questions-réponses.

— Editorial Team