Ajustement fin

Le fine-tuning consiste à poursuivre l’entraînement d’un grand modèle pré-entraîné sur un jeu de données plus restreint, spécifique à une tâche ou à un domaine. Par exemple, un fine-tuning sur un jeu de données d’exemples de code permet au modèle de s’améliorer en programmation. Le fine-tuning est identique au pré-entraînement, à l’exception du fait que l’on ne démarre pas avec des poids aléatoires. Il nécessite également beaucoup moins de calcul, de données et de temps.

Le tutoriel ci-dessous détaille la fine-tuning d'un grand modèle de langage avec Trainer.

Connectez-vous à votre compte Hugging Face avec votre jeton d'utilisateur pour pousser votre modèle affiné sur le Hub.

from huggingface_hub import login

login()

Tokenisation

Chargez un jeu de données et tokenisez la colonne de texte sur laquelle le modèle s'entraîne (horoscope dans le jeu de données ci-dessous).

Le tokenizer crée les entrées du modèle, input_ids et attention_mask. La méthode forward du modèle n’accepte que input_ids et attention_mask, il faut donc définir remove_columns pour supprimer des colonnes comme horoscope après la tokenization.

• Définissez truncation=True et une max_length pour tronquer les séquences plus longues à une longueur maximale spécifiée.
• Utilisez la méthode train_test_split pour créer un ensemble de test afin d'évaluer le modèle.

from datasets import load_dataset
from transformers import AutoTokenizer, DataCollatorForLanguageModeling

model_name = "Qwen/Qwen3-0.6B"
tokenizer = AutoTokenizer.from_pretrained(model_name)
dataset = load_dataset("karthiksagarn/astro_horoscope", split="train")

def tokenize(batch):
    return tokenizer(
        batch["horoscope"],
        truncation=True,
        max_length=512,
    )

dataset = dataset.map(tokenize, batched=True, remove_columns=dataset.column_names)
dataset = dataset.train_test_split(test_size=0.1)

Un collateur de données assemble des échantillons du jeu de données en lots pour le traitement par le modèle. DataCollatorForLanguageModeling effectue un rembourrage dynamique de chaque lot jusqu'à la séquence la plus longue de ce lot, plutôt que de rembourrer toutes les séquences du jeu de données à la même longueur. Cela économise des ressources de calcul et de mémoire en évitant le calcul de jetons de rembourrage inutiles.

• Définissez mlm=False pour éviter le masquage aléatoire des jetons.

data_collator = DataCollatorForLanguageModeling(tokenizer, mlm=False)

Chargement d'un modèle

Chargez un point de contrôle préentraîné pour l’affiner (voir le guide Chargement des modèles pour plus de détails sur le chargement des modèles).

• Définissez dtype="auto" pour charger les poids dans leur dtype d'origine. Sans cela, PyTorch charge les poids en torch.float32, ce qui double l'utilisation de la mémoire si les poids sont initialement en torch.bfloat16.

from transformers import AutoModelForCausalLM, TrainingArguments, Trainer

model_name = "Qwen/Qwen3-0.6B"
model = AutoModelForCausalLM.from_pretrained(model_name, dtype="auto")

Configuration de l'entraînement

TrainingArguments fournit toutes les options permettant de personnaliser une session d’entraînement. Seuls les arguments les plus courants sont abordés ici. Les autres disposent de valeurs par défaut raisonnables ou ne concernent que des scénarios spécifiques, comme l’entraînement distribué. Consultez la documentation de l’API TrainingArguments pour obtenir la liste complète des arguments.

training_args = TrainingArguments(
    output_dir="qwen3-finetuned",
    num_train_epochs=3,
    per_device_train_batch_size=2,
    gradient_accumulation_steps=8,
    gradient_checkpointing=True,
    gradient_checkpointing_kwargs={"every_n_layers": 4},
    bf16=True,
    learning_rate=2e-5,
    logging_steps=10,
    eval_strategy="epoch",
    save_strategy="epoch",
    load_best_model_at_end=True,
)

Entraînement

Créez une instance de Trainer avec tous les composants nécessaires, puis appelez train() pour démarrer.

trainer = Trainer(
    model=model,
    args=training_args,
    train_dataset=dataset["train"],
    eval_dataset=dataset["test"],
    processing_class=tokenizer,
    data_collator=DataCollatorForLanguageModeling(tokenizer, mlm=False),
)

trainer.train()
trainer.push_to_hub()

push_to_hub() téléverse les poids affinés, la configuration de génération, le tokenizer et la configuration du modèle sur le Hub.

Étapes suivantes

• Consultez le guide Fonctionnalités du Trainer pour des exemples de code fonctionnels et minimaux des fonctionnalités courantes du Trainer, telles que les fonctions de perte personnalisées, l'évaluation économe en mémoire, le checkpointing, et bien d'autres.
• Consultez le guide Méthodes de sous-classement de Trainer pour apprendre à sous-classez les méthodes de Trainer afin de prendre en charge de nouvelles fonctionnalités et des fonctionnalités personnalisées.
• Consultez le guide Callbacks pour apprendre à vous connecter aux événements d’entraînement afin de gérer la journalisation, l’arrêt anticipé et d’autres comportements personnalisés.
• Consultez le guide Data collators pour apprendre à personnaliser l'assemblage des échantillons en lots.
• Exécuter un script d’entraînement sur un GPU loué avec Hugging Face Jobs.
• Parcourez les notebooks ou la section Resources > Task Recipes pour trouver des exemples de formation supplémentaires sur différentes tâches de texte, audio, vision et multimodales.