QLoRA

QLoRA (adaptation de bas rang quantifiée) est une méthode de fine-tuning qui gèle un grand modèle de langage (LLM) préentraîné en précision 4 bits et entraîne de petits adaptateurs LoRA par-dessus, en rétropropageant les gradients à travers les poids quantifiés jusqu’aux adaptateurs. Présentée par Dettmers et al. dans l’article QLoRA de 2023, cette méthode a réduit la mémoire GPU nécessaire au fine-tuning d’un modèle de 65 milliards de paramètres de plus de 780 Go à moins de 48 Go, ce qui permet de l’effectuer sur un seul GPU de station de travail, tout en égalant les performances de la précision 16 bits pour la tâche. Les modèles Guanaco de l’article, ajustés de cette façon, ont obtenu 99,3 % du score de ChatGPT sur le benchmark Vicuna après 24 heures d’entraînement sur un seul GPU.

Fonctionnement de QLoRA#

QLoRA combine un modèle de base gelé et compressé avec trois techniques d’économie de mémoire :

• NormalFloat 4 bits (NF4) : Chaque poids est stocké sous la forme d’un code de 4 bits correspondant à l’un des 16 niveaux placés aux quantiles d’une distribution normale, avec un facteur d’échelle du maximum absolu par bloc de 64 poids. Les poids des modèles préentraînés suivent approximativement une distribution normale ; les niveaux par quantiles offrent donc une meilleure résolution près de zéro, là où se trouvent la plupart des poids.
• Double quantification : Les facteurs d’échelle par bloc sont eux-mêmes quantifiés sur 8 bits par blocs de 256, ce qui réduit leur surcoût de 0,5 à environ 0,127 bit par paramètre et permet d’économiser environ 3 Go sur un modèle de 65B.
• Optimiseurs paginés : Les états de l’optimiseur résident dans la mémoire unifiée de NVIDIA et sont transférés vers la RAM du CPU en cas de pics de mémoire, par exemple lors du traitement de longues séquences avec le checkpointing des gradients, afin d’éviter l’arrêt de l’entraînement pour cause de mémoire insuffisante.

Lors de la propagation avant, chaque couche gelée déquantifie ses poids NF4 en bfloat16 juste avant la multiplication matricielle et ajoute la sortie du chemin LoRA. La rétropropagation calcule les gradients à travers les poids déquantifiés, mais ne met à jour que les deux matrices LoRA de bas rang. L’article a montré que l’ajout d’adaptateurs à chaque couche linéaire du bloc Transformer était nécessaire pour égaler le fine-tuning complet :

L’extrait ci-dessous construit les niveaux NF4 selon la méthode de la bibliothèque bitsandbytes et les compare à 16 niveaux équidistants sur des blocs de poids distribués normalement :

import torch

torch.manual_seed(0)
normal = torch.distributions.Normal(0.0, 1.0)
# NF4: 16 levels at quantiles of a normal distribution, with an exact zero (as built in bitsandbytes)
positive = normal.icdf(torch.linspace(0.9677083, 0.5, 9)[:-1])
negative = -normal.icdf(torch.linspace(0.9677083, 0.5, 8)[:-1])
nf4 = torch.cat([negative, torch.zeros(1), positive]).sort().values
nf4 = nf4 / nf4.max()
int4 = torch.linspace(-1, 1, 16)  # evenly spaced 4-bit levels for comparison

weights = torch.randn(4096, 64) * 0.02  # pretrained weights are roughly normal, in blocks of 64
absmax = weights.abs().amax(dim=1, keepdim=True)  # one scale per block
for name, levels in (("NF4", nf4), ("INT4", int4)):
    codes = ((weights / absmax)[..., None] - levels).abs().argmin(dim=-1)  # 4-bit index per weight
    restored = levels[codes] * absmax
    print(f"{name} mean squared error: {(restored - weights).pow(2).mean():.3e}")

Il affiche une erreur quadratique moyenne de 3.395e-06 pour NF4 et de 4.053e-06 pour les niveaux équidistants : avec les mêmes 16 niveaux et les mêmes facteurs d’échelle par bloc, l’espacement par quantiles de NF4 réduit d’environ 16 % l’erreur de reconstruction pour des poids distribués normalement. En pratique, Hugging Face Transformers charge un modèle en NF4 avec bitsandbytes et un BitsAndBytesConfig qui définit load_in_4bit=True, bnb_4bit_quant_type="nf4", bnb_4bit_use_double_quant=True et bnb_4bit_compute_dtype=torch.bfloat16 ; la bibliothèque PEFT ajoute les adaptateurs LoRA.

QLoRA et les méthodes connexes#

• LoRA : Entraîne le même type d’adaptateurs sur un modèle de base conservé en précision 16 bits. Les poids 16 bits d’un modèle de 65B occupent à eux seuls environ 130 Go, tandis que NF4 les stocke dans environ un quart de cet espace.
• Fine-tuning efficace en paramètres (PEFT) : Famille de méthodes qui entraînent un petit ensemble de paramètres, dont LoRA, QLoRA, les adaptateurs et l’ajustement de prompt.
• Quantification du modèle après entraînement : Compresse un modèle finalisé pour l’inférence. Un modèle ajusté avec QLoRA est souvent fusionné dans des poids 16 bits, puis quantifié à nouveau pour le déploiement.
• Entraînement tenant compte de la quantification (QAT) : Simule l’arrondi à faible précision lors de la propagation avant, tandis que tous les poids sont entraînés, afin que le modèle déployé conserve sa précision en faible précision. Ultralytics YOLO26 effectue un QAT INT8 lors de l’entraînement avec quantize=8 ; il insère une fausse quantification dans ses couches convolutives et linéaires via NVIDIA ModelOpt afin que les poids appris résistent à l’exportation en INT8.

Compromis#

QLoRA privilégie la mémoire à la vitesse : la déquantification de chaque poids gelé à chaque propagation avant et arrière ralentit une étape d’entraînement par rapport à LoRA en 16 bits. Les adaptateurs sont assez petits pour être stockés et remplacés selon la tâche, mais leur fusion avec le modèle de base nécessite d’abord de le déquantifier en 16 bits. Pour le modèle 65B, les poids 4 bits et les facteurs d’échelle à double quantification occupent environ 34 Go, laissant le reste des 48 Go d’un GPU pour les adaptateurs, les activations et les états paginés de l’optimiseur.