Transformers documentation

Ajuster finement un modèle

Hugging Face's logo
Join the Hugging Face community

and get access to the augmented documentation experience

to get started

Ajuster finement un modèle

Les poids quantifiés ne peuvent pas être mis à jour directement par les gradients, vous affinez donc un modèle quantifié en entraînant un petit adaptateur au-dessus des poids quantisés figés. L’entraînement d’un adaptateur LoRA sur un modèle 4 bits est connu sous le nom de QLoRA, et il permet d’affiner un modèle qui ne tiendrait pas en mémoire en bf16.

Trainer vérifie le modèle avant l’entraînement afin de s’assurer que :

  • La méthode de quantisation prend en charge l’entraînement. Consultez la colonne Fine-tune dans Choisir une méthode.
  • Le modèle dispose d'un adaptateur entraînable. Les méthodes prenant en charge l'entraînement conscient de la quantification font exception et sont décrites ci-dessous.
  • Le modèle n’est pas compilé avec torch.compile.

Entraîner un adaptateur

Installer PEFT.

pip install -U peft

Chargez le modèle avec une méthode qui prend en charge l'entraînement, attachez un adaptateur LoRA avec add_adapter() et passez le modèle à Trainer. L'exemple ci-dessous utilise bitsandbytes en 4 bits et suppose que train_dataset est un jeu de données tokenisé.

import torch
from peft import LoraConfig
from transformers import AutoModelForCausalLM, BitsAndBytesConfig, Trainer, TrainingArguments

quantization_config = BitsAndBytesConfig(
    load_in_4bit=True,
    bnb_4bit_quant_type="nf4",
    bnb_4bit_compute_dtype=torch.bfloat16,
)
model = AutoModelForCausalLM.from_pretrained(
    "Qwen/Qwen3-0.6B",
    quantization_config=quantization_config,
    device_map="auto",
)

lora_config = LoraConfig(r=16, lora_alpha=32, target_modules="all-linear", task_type="CAUSAL_LM")
model.add_adapter(lora_config)

trainer = Trainer(
    model=model,
    args=TrainingArguments(output_dir="qwen3-qlora", bf16=True),
    train_dataset=train_dataset,
)
trainer.train()

Seuls les poids de l'adaptateur sont entraînés. Les poids de base quantifiés restent figés.

Enregistrer l'adaptateur

save_pretrained() n’enregistre que les poids de l’adaptateur, qui ne représentent que quelques mégaoctets. Cela fonctionne avec toutes les méthodes, y compris celles qui ne peuvent pas enregistrer leurs poids quantifiés.

model.save_pretrained("qwen3-qlora-adapter")

Pour utiliser l'adaptateur, chargez le modèle de base avec la même configuration de quantification, puis chargez l'adaptateur par-dessus. Consultez Chargement d'un adaptateur pour plus de détails.

Entraînement tenant compte de la quantification

BitNet et compressed-tensors peuvent entraîner le modèle complet sans adaptateur, à condition que les poids restent sous une forme entraînable.

  • BitNet nécessite linear_class="autobitlinear" et quantization_mode="online" dans BitNetQuantConfig.
  • compressed-tensors nécessite un checkpoint non compressé, ou dequantize=True dans CompressedTensorsConfig. Les checkpoints qui utilisent les noyaux FP8 ne peuvent pas être entraînés.

Voir Concepts de quantification pour comprendre en quoi l’entraînement conscient de la quantification diffère de la quantification après entraînement.

Update on GitHub