# 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 petit, spécifique à une tâche ou à un domaine. Par exemple, un fine-tuning sur un jeu de données d'exemples de code aide le modèle à 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 calculs, de données et de temps.

Le tutoriel ci-dessous détaille la fine-tuning d'un grand modèle de langage avec [Trainer](/docs/transformers/v5.23.0/fr/main_classes/trainer#transformers.Trainer).

> [!AgentPrompt]
> Aidez l'utilisateur à planifier une exécution de fine-tuning pour sa tâche. Avant de proposer une configuration, identifiez la tâche, le modèle pré-entraîné et sa révision, les champs du jeu de données, les données d'évaluation, la version de Transformers, le matériel et la mémoire disponible. Utilisez ce tutoriel pour vérifier la préparation des données, le chargement du modèle et la configuration de `Trainer` qui s'appliquent à son cas. Ne supposez pas que le jeu de données ou le modèle de l'exemple convient à une tâche différente.
>
> 1. Demander les détails manquants susceptibles de modifier le modèle, le prétraitement ou la configuration d’entraînement. Formuler les hypothèses. 2. Garder les exemples d’évaluation séparés des données d’entraînement. Sélectionner un modèle et un tokenizer pour la tâche, préparer les entrées et les étiquettes attendues par le modèle, et choisir un data collator adapté à ces entrées. 3. Configurer `TrainingArguments` en fonction du matériel et des objectifs de l’utilisateur. Configurer l’évaluation et l’enregistrement des points de contrôle si l’utilisateur en a besoin. Exécuter un petit test avant un entraînement complet, et vérifier que le modèle reçoit les entrées attendues, que la perte est finie et que l’évaluation se termine. 4. Ne pas démarrer un entraînement complet ni téléverser d’artefacts sauf si l’utilisateur le demande. Signaler la configuration proposée, les preuves issues de tout test, les compromis de ressources attendus et tout ce qui n’a pas pu être vérifié.

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

```py
from huggingface_hub import login

login()
```

## Tokenisation

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

<iframe src="https://huggingface.co/datasets/karthiksagarn/astro_horoscope/embed/viewer/default/train" frameborder="0" width="100%" height="560px"
>

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.

```py
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](/docs/transformers/v5.23.0/fr/main_classes/data_collator#transformers.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.

```py
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](./models) 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`.

```py
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](/docs/transformers/v5.23.0/fr/main_classes/trainer#transformers.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](/docs/transformers/v5.23.0/fr/main_classes/trainer#transformers.TrainingArguments) pour obtenir la liste complète des arguments.

- `num_train_epochs` et `per_device_train_batch_size` contrôlent la durée de l’entraînement et la taille du lot. `learning_rate` définit le taux d’apprentissage initial de l’optimiseur.

- Définissez `bf16=True` pour un entraînement rapide en précision mixte si votre matériel le prend en charge (GPU Ampere et ultérieurs). Sinon, utilisez `fp16=True` sur un matériel plus ancien.
- `gradient_accumulation_steps` simule une taille de lot effective plus grande en accumulant les gradients sur plusieurs passes avant de mettre à jour les poids.
- `gradient_checkpointing` échange des calculs contre de la mémoire en recalculant les activations intermédiaires lors de la passe arrière au lieu de les stocker. Pour un compromis entre la mémoire et la vitesse, consultez [partial checkpointing](./grad_checkpointing#partial-checkpointing).
- Lorsque `gradient_checkpointing=True`, définissez `gradient_checkpointing_kwargs={"offload": True}` pour conserver les activations enregistrées en mémoire hôte épinglée et réduire l’utilisation de la mémoire GPU pour les séquences longues. Consultez [le déchargement des activations enregistrées](./grad_checkpointing#offloading-the-saved-activations) pour connaître le compromis.
- Définissez `train_sampling_strategy="group_by_length"` pour regrouper par lots des exemples de longueurs similaires et réduire le bourrage. Consultez [group samples by length](./trainer_recipes#group-samples-by-length) pour les jeux de données multimodaux basés sur des processeurs et les longueurs précalculées.

- `eval_strategy` et `save_strategy` déterminent quand évaluer un modèle pendant l’entraînement et quand enregistrer un point de contrôle.
- `load_best_model_at_end` charge le meilleur point de contrôle à la fin de l’entraînement. Il nécessite que `eval_strategy` soit défini.

- `logging_steps` contrôle la fréquence à laquelle la perte est mise à jour et renvoyée pendant l’entraînement.

```py
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](/docs/transformers/v5.23.0/fr/main_classes/trainer#transformers.Trainer) avec tous les composants nécessaires, puis appelez [train()](/docs/transformers/v5.23.0/fr/main_classes/trainer#transformers.Trainer.train) pour démarrer.

```py
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()](/docs/transformers/v5.23.0/fr/main_classes/trainer#transformers.Trainer.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](./trainer_recipes) 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](./trainer_customize) pour apprendre à sous-classez les méthodes de [Trainer](/docs/transformers/v5.23.0/fr/main_classes/trainer#transformers.Trainer) afin de prendre en charge de nouvelles fonctionnalités et des fonctionnalités personnalisées.
- Consultez le guide [Callbacks](./trainer_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](./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](https://huggingface.co/docs/hub/jobs-training).
- Parcourez les [notebooks](./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.

