# SFT Trainer

[![All_models-SFT-blue](https://img.shields.io/badge/All_models-SFT-blue)](https://huggingface.co/models?other=sft,trl) [![smol_course-Chapter_1-yellow](https://img.shields.io/badge/smol_course-Chapter_1-yellow)](https://github.com/huggingface/smol-course/tree/main/1_instruction_tuning)

## Aperçu

TRL prend en charge le Supervised Fine-Tuning (SFT) Trainer pour l'entraînement des modèles de langage.

[SFTTrainer](/docs/trl/v1.18.2/fr/sft_trainer#trl.SFTTrainer) ne prend pas nativement en charge les modèles de diffusion comme DiffusionGemma, mais il peut être facilement étendu pour le faire, voir l'[exemple de SFT block-diffusion](https://github.com/huggingface/trl/blob/main/examples/sft_diffusion_gemma/sft_diffusion_gemma.py).

Cette méthode de post-entraînement a été proposée par [Younes Belkada](https://huggingface.co/ybelkada).

## Démarrage rapide

Cet exemple montre comment entraîner un modèle de langage à l'aide de [SFTTrainer](/docs/trl/v1.18.2/fr/sft_trainer#trl.SFTTrainer) de TRL. Nous entraînons un modèle [Qwen 3 0.6B](https://huggingface.co/Qwen/Qwen3-0.6B) sur le [Capybara dataset](https://huggingface.co/datasets/trl-lib/Capybara), un jeu de données compact et diversifié, multi-tours, destiné à évaluer le raisonnement et la généralisation.

```python
from trl import SFTTrainer
from datasets import load_dataset

trainer = SFTTrainer(
    model="Qwen/Qwen3-0.6B",
    train_dataset=load_dataset("trl-lib/Capybara", split="train"),
)
trainer.train()
```

## Type et format de jeu de données attendus

SFT prend en charge à la fois les jeux de données de [modélisation du langage](dataset_formats#language-modeling) et de [complétion de prompt](dataset_formats#prompt-completion). Le [SFTTrainer](/docs/trl/v1.18.2/fr/sft_trainer#trl.SFTTrainer) est compatible avec les formats de jeu de données [standard](dataset_formats#standard) et [conversationnel](dataset_formats#conversational). Lorsqu’un jeu de données conversationnel est fourni, l’entraîneur applique automatiquement le modèle de chat au jeu de données.

```python
# Standard language modeling
{"text": "The sky is blue."}

# Conversational language modeling
{"messages": [{"role": "user", "content": "What color is the sky?"},
              {"role": "assistant", "content": "It is blue."}]}

# Standard prompt-completion
{"prompt": "The sky is",
 "completion": " blue."}

# Conversational prompt-completion
{"prompt": [{"role": "user", "content": "What color is the sky?"}],
 "completion": [{"role": "assistant", "content": "It is blue."}]}
```

Si votre jeu de données n'est pas dans l'un de ces formats, vous pouvez le prétraiter pour le convertir dans le format attendu. Voici un exemple avec le jeu de données [FreedomIntelligence/medical-o1-reasoning-SFT](https://huggingface.co/datasets/FreedomIntelligence/medical-o1-reasoning-SFT) :

```python
from datasets import load_dataset

dataset = load_dataset("FreedomIntelligence/medical-o1-reasoning-SFT", "en")

def preprocess_function(example):
    return {
        "prompt": [{"role": "user", "content": example["Question"]}],
        "completion": [
            {"role": "assistant", "content": f"<think>{example['Complex_CoT']}</think>{example['Response']}"}
        ],
    }

dataset = dataset.map(preprocess_function, remove_columns=["Question", "Response", "Complex_CoT"])
print(next(iter(dataset["train"])))
```

```json
{
    "prompt": [
        {
            "content": "Given the symptoms of sudden weakness in the left arm and leg, recent long-distance travel, and the presence of swollen and tender right lower leg, what specific cardiac abnormality is most likely to be found upon further evaluation that could explain these findings?",
            "role": "user",
        }
    ],
    "completion": [
        {
            "content": "<think>Okay, let's see what's going on here. We've got sudden weakness [...] clicks into place!</think>The specific cardiac abnormality most likely to be found in [...] the presence of a PFO facilitating a paradoxical embolism.",
            "role": "assistant",
        }
    ],
}
```

## Explorer plus en profondeur la méthode SFT

Le Supervised Fine-Tuning (SFT) est la méthode la plus simple et la plus couramment utilisée pour adapter un modèle de langage à un jeu de données cible. Le modèle est entraîné de manière entièrement supervisée à l'aide de paires de séquences d'entrée et de sortie. L'objectif est de minimiser la négative log-vraisemblance (NLL) de la séquence cible, en conditionnant sur l'entrée.

Cette section détaille le fonctionnement pratique du SFT en abordant les étapes clés : **prétraitement**, **tokenisation** et **calcul de la perte**.

### Prétraitement et tokenisation

Lors de l'entraînement, chaque exemple est censé contenir un **champ text** ou une paire **(prompt, completion)**, selon le format du jeu de données. Pour plus de détails sur les formats attendus, consultez [Formats de jeu de données](dataset_formats). Le [SFTTrainer](/docs/trl/v1.18.2/fr/sft_trainer#trl.SFTTrainer) tokenise chaque entrée à l'aide du tokenizer du modèle. Si le prompt et la completion sont fournis séparément, ils sont concaténés avant la tokenisation.

### Calcul de la perte

![sft_figure](https://huggingface.co/datasets/trl-lib/documentation-images/resolve/main/sft_figure.png)

La perte utilisée dans le SFT est la **perte d'entropie croisée au niveau des jetons**, définie comme suit :

$$ \mathcal{L}_{\text{SFT}}(\theta) = - \sum_{t=1}^{T} \log p_\theta(y_t \mid y_{<t}), $$

où \\( y_t \\) est le jeton cible à l'instant \\( t \\), et le modèle est entraîné à prédire le jeton suivant à partir des précédents. En pratique, les jetons de bourrage sont masqués lors du calcul de la perte.

> [!TIP]
> L'article [On the Generalization of SFT: A Reinforcement Learning Perspective with Reward Rectification](https://huggingface.co/papers/2508.05629) propose une fonction de perte alternative, appelée **Dynamic Fine-Tuning (DFT)**, qui vise à améliorer la généralisation en rectifiant le signal de récompense. Cette méthode peut être activée en définissant `loss_type="dft"` dans [SFTConfig](/docs/trl/v1.18.2/fr/sft_trainer#trl.SFTConfig). Pour plus de détails, voir [Paper Index - Dynamic Fine-Tuning](paper_index#on-the-generalization-of-sft-a-reinforcement-learning-perspective-with-reward-rectification).

### Décalage et masquage des étiquettes

Lors de l'entraînement, la perte est calculée en utilisant un **décalage d'un jeton** : le modèle est entraîné à prédire chaque jeton de la séquence sur la base de tous les jetons précédents. Plus précisément, la séquence d'entrée est décalée d'une position vers la droite pour former les étiquettes cibles. Les jetons de bourrage (le cas échéant) sont ignorés dans le calcul de la perte en appliquant un index d'ignorance (par défaut : `-100`) aux positions correspondantes. Cela garantit que la perte ne porte que sur les jetons significatifs, non bourrés.

## Métriques journalisées

Lors de l'entraînement et de l'évaluation, nous enregistrons les métriques suivantes :

- `global_step` : le nombre total d'étapes d'optimiseur effectuées jusqu'à présent.
- `epoch` : numéro de l'époque en cours, basé sur l'itération du jeu de données.
- `num_tokens` : le nombre total de jetons traités jusqu'à présent.
- `loss` : La perte d'entropie croisée moyenne calculée sur les jetons non masqués dans l'intervalle de journalisation actuel.
- `entropy` : l'entropie moyenne de la distribution de jetons prédite par le modèle sur les jetons non masqués.
- `aux_loss` : perte auxiliaire d'équilibrage de charge d'un modèle Mixture-of-Experts, avant d'être mise à l'échelle par `router_aux_loss_coef` et ajoutée à la perte. Journalisée uniquement lorsque le modèle est un modèle MoE et que `router_aux_loss_coef` est non nul.
- `mean_token_accuracy` : La proportion de jetons non masqués pour lesquels la prédiction top-1 du modèle correspond au jeton de référence.
- `learning_rate` : le taux d'apprentissage actuel, susceptible de changer dynamiquement si un planificateur est utilisé.
- `grad_norm` : la norme L2 des gradients, calculée avant le rognage des gradients.

## Personnalisation

### Initialisation du modèle

Vous pouvez passer directement les kwargs de la méthode `from_pretrained()` à [SFTConfig](/docs/trl/v1.18.2/fr/sft_trainer#trl.SFTConfig). Par exemple, si vous souhaitez charger un modèle dans une précision différente, de manière analogue à

```python
model = AutoModelForCausalLM.from_pretrained("Qwen/Qwen3-0.6B", dtype=torch.bfloat16)
```

vous pouvez le faire en passant l'argument `model_init_kwargs={"dtype": torch.bfloat16}` à [SFTConfig](/docs/trl/v1.18.2/fr/sft_trainer#trl.SFTConfig).

```python
from trl import SFTConfig

training_args = SFTConfig(
    model_init_kwargs={"dtype": torch.bfloat16},
)
```

Notez que tous les arguments par mot-clé de `from_pretrained()` sont pris en charge.

### Packing

[SFTTrainer](/docs/trl/v1.18.2/fr/sft_trainer#trl.SFTTrainer) prend en charge le _paquetage d’exemples_, qui consiste à regrouper plusieurs exemples dans la même séquence d’entrée afin d’augmenter l’efficacité de l’entraînement. Pour activer le paquetage, il suffit de passer `packing=True` au constructeur de [SFTConfig](/docs/trl/v1.18.2/fr/sft_trainer#trl.SFTConfig).

```python
training_args = SFTConfig(packing=True)
```

Pour plus de détails sur le packing, voir [Packing](reducing_memory_usage#packing).

### Entraîner uniquement sur les messages de l'assistant

Pour entraîner uniquement sur les messages de l'assistant, utilisez un jeu de données [conversationnel](dataset_formats#conversational) et définissez `assistant_only_loss=True` dans [SFTConfig](/docs/trl/v1.18.2/fr/sft_trainer#trl.SFTConfig). Ce paramètre garantit que la perte est calculée **uniquement** sur les réponses de l'assistant, en ignorant les messages utilisateur ou système.

```python
training_args = SFTConfig(assistant_only_loss=True)
```

![train_on_assistant](https://huggingface.co/datasets/trl-lib/documentation-images/resolve/main/train_on_assistant.png)

> [!WARNING]
> Cette fonctionnalité nécessite que le modèle de chat inclue les mots-clés `{% generation %}` et `{% endgeneration %}`. Pour les familles de modèles connues (par ex. Qwen3), TRL applique automatiquement un correctif au modèle lorsque `assistant_only_loss=True`. Consultez [Chat Templates](chat_templates#training-templates) pour la liste complète des modèles d’entraînement inclus. Pour les autres modèles, vérifiez que votre modèle de chat inclut ces mots-clés. Consultez [HuggingFaceTB/SmolLM3-3B](https://huggingface.co/HuggingFaceTB/SmolLM3-3B/blob/main/chat_template.jinja#L76-L82) pour un exemple.

> [!NOTE]
> Avec un [jeu de données visuel](#training-vision-language-models), la perte uniquement sur l'assistant nécessite `transformers>=5.18.0` et un jeu de données de [modélisation du langage](dataset_formats#language-modeling) conversationnel.

### Entraîner uniquement sur la complétion

Pour entraîner uniquement sur la complétion, utilisez un jeu de données [prompt-completion](dataset_formats#prompt-completion). Par défaut, l'entraîneur calcule la perte uniquement sur les jetons de complétion, en ignorant les jetons du prompt. Si vous souhaitez entraîner sur la séquence complète, définissez `completion_only_loss=False` dans [SFTConfig](/docs/trl/v1.18.2/fr/sft_trainer#trl.SFTConfig).

```python
from trl import SFTConfig, SFTTrainer
from datasets import load_dataset

# Load a prompt-completion dataset; loss is computed on the completion only by default
dataset = load_dataset("trl-lib/kto-mix-14k", split="train")

trainer = SFTTrainer(
    model="Qwen/Qwen2.5-0.5B-Instruct",
    args=SFTConfig(completion_only_loss=True),  # True by default for prompt-completion datasets
    train_dataset=dataset,
)
trainer.train()
```

![train_on_completion](https://huggingface.co/datasets/trl-lib/documentation-images/resolve/main/train_on_completion.png)

> [!TIP]
> L'entraînement sur les complétions uniquement est compatible avec l'entraînement sur les messages d'assistant uniquement. Dans ce cas, utilisez un jeu de données [conversationnel](dataset_formats#conversational) [prompt-complétion](dataset_formats#prompt-completion) et définissez `assistant_only_loss=True` dans [SFTConfig](/docs/trl/v1.18.2/fr/sft_trainer#trl.SFTConfig).

### Entraîner des adaptateurs avec PEFT

Nous prenons en charge une intégration étroite avec la bibliothèque 🤗 PEFT, permettant à tout utilisateur d’entraîner et de partager des adaptateurs sur le Hub de manière pratique, plutôt que d’entraîner l’ensemble du modèle.

```python
from datasets import load_dataset
from trl import SFTTrainer
from peft import LoraConfig

dataset = load_dataset("trl-lib/Capybara", split="train")

trainer = SFTTrainer(
    "Qwen/Qwen3-0.6B",
    train_dataset=dataset,
    peft_config=LoraConfig(),
)

trainer.train()
```

Vous pouvez également poursuivre l’entraînement de votre [PeftModel](https://huggingface.co/docs/peft/v0.22.0/en/package_reference/peft_model#peft.PeftModel). Pour cela, chargez d’abord un `PeftModel` en dehors de [SFTTrainer](/docs/trl/v1.18.2/fr/sft_trainer#trl.SFTTrainer) et transmettez-le directement au formateur sans passer l’argument `peft_config`.

```python
from datasets import load_dataset
from trl import SFTTrainer
from peft import AutoPeftModelForCausalLM

model = AutoPeftModelForCausalLM.from_pretrained("trl-lib/Qwen3-4B-LoRA", is_trainable=True)
dataset = load_dataset("trl-lib/Capybara", split="train")

trainer = SFTTrainer(
    model=model,
    train_dataset=dataset,
)

trainer.train()
```

> [!TIP]
> Lors de l’entraînement d’adapters, vous utilisez généralement un taux d’apprentissage plus élevé (≈1e‑4) puisque seuls les nouveaux paramètres sont appris.
>
> ```python
> SFTConfig(learning_rate=1e-4, ...)
> ```

### Expérimentation rapide pour le SFT

RapidFire AI est un moteur d’expérimentation open source qui s’appuie sur TRL et vous permet de lancer plusieurs configurations SFT simultanément, même sur un seul GPU. Plutôt que d’essayer les configurations séquentiellement, RapidFire vous permet de **visualiser plus tôt toutes leurs courbes d’apprentissage, d’arrêter les exécutions sous-performantes et de cloner les prometteuses avec de nouveaux paramètres en cours d’exécution** sans redémarrage. Pour plus d’informations, consultez [Intégration RapidFire AI](rapidfire_integration).

### Entraîner avec Unsloth

Unsloth est un framework open source pour le fine-tuning et l'apprentissage par renforcement qui entraîne les LLM (comme Llama, Mistral, Gemma, DeepSeek, etc.) jusqu'à 2 fois plus rapidement avec jusqu'à 70 % de VRAM en moins, tout en offrant un flux de travail simplifié et compatible Hugging Face pour l'entraînement, l'évaluation et le déploiement. Pour plus d'informations, consultez [Intégration Unsloth](unsloth_integration).

## Exemple d’instruction tuning

**L’instruction tuning** apprend à un modèle de langage de base à suivre les instructions de l’utilisateur et à engager des conversations. Cela nécessite :

1. **Modèle de discussion** : Définit comment structurer les conversations en séquences de texte, y compris les marqueurs de rôle (utilisateur/assistant), les jetons spéciaux et les limites de tour. En savoir plus sur les modèles de discussion dans [Modèles de discussion](https://huggingface.co/docs/transformers/chat_templating#templates).
2. **Jeu de données conversationnel** : Contient des paires instruction-réponse

Cet exemple montre comment transformer le modèle [Qwen 3 0.6B Base](https://huggingface.co/Qwen/Qwen3-0.6B-Base) en un modèle suivant des instructions à l'aide du [jeu de données Capybara](https://huggingface.co/datasets/trl-lib/Capybara) et d'un modèle de chat issu de [HuggingFaceTB/SmolLM3-3B](https://huggingface.co/HuggingFaceTB/SmolLM3-3B). Le SFT Trainer gère automatiquement les mises à jour du tokenizer et la configuration des jetons spéciaux.

```python
from trl import SFTConfig, SFTTrainer
from datasets import load_dataset

trainer = SFTTrainer(
    model="Qwen/Qwen3-0.6B-Base",
    args=SFTConfig(
        output_dir="Qwen3-0.6B-Instruct",
        chat_template_path="HuggingFaceTB/SmolLM3-3B",
    ),
    train_dataset=load_dataset("trl-lib/Capybara", split="train"),
)
trainer.train()
```

> [!WARNING]
> Certains modèles de base, comme ceux de Qwen, disposent d’un modèle de chat prédéfini dans le tokenizer du modèle. Dans ces cas, il n’est pas nécessaire d’appliquer `clone_chat_template()`, car le tokenizer gère déjà le formatage. Il est toutefois nécessaire d’aligner le jeton EOS avec le modèle de chat afin de garantir que les réponses du modèle se terminent correctement. Dans ces cas, spécifiez `eos_token` dans [SFTConfig](/docs/trl/v1.18.2/fr/sft_trainer#trl.SFTConfig) ; par exemple, pour `Qwen/Qwen2.5-1.5B`, il convient de définir `eos_token="<|im_end|>"`.

Une fois entraîné, votre modèle peut désormais suivre des instructions et engager des conversations à l'aide de son nouveau modèle de discussion.

```python
>>> from transformers import pipeline
>>> pipe = pipeline("text-generation", model="Qwen3-0.6B-Instruct/checkpoint-5000")
>>> prompt = "<|im_start|>user\nWhat is the capital of France? Answer in one word.<|im_end|>\n<|im_start|>assistant\n"
>>> response = pipe(prompt)
>>> response[0]["generated_text"]
'<|im_start|>user\nWhat is the capital of France? Answer in one word.<|im_end|>\n<|im_start|>assistant\nThe capital of France is Paris.'
```

Sinon, utilisez le format de conversation structuré (recommandé) :

```python
>>> prompt = [{"role": "user", "content": "What is the capital of France? Answer in one word."}]
>>> response = pipe(prompt)
>>> response[0]["generated_text"]
[{'role': 'user', 'content': 'What is the capital of France? Answer in one word.'}, {'role': 'assistant', 'content': 'The capital of France is Paris.'}]
```

## Appel d'outils avec SFT

Le [SFTTrainer](/docs/trl/v1.18.2/fr/sft_trainer#trl.SFTTrainer) prend entièrement en charge le fine-tuning de modèles dotés de capacités de _tool calling_. Dans ce cas, chaque exemple du jeu de données doit inclure :

- Les messages de la conversation, y compris les appels d'outils (`tool_calls`) et les réponses d'outils (messages avec le rôle `tool`)
- La liste des outils disponibles dans la colonne `tools`, généralement fournie sous forme de schémas JSON

Pour plus de détails sur la structure attendue du jeu de données, consultez la section [Format du jeu de données — Tool Calling](dataset_formats#tool-calling).

## Entraînement des modèles de vision et de langage

[SFTTrainer](/docs/trl/v1.18.2/fr/sft_trainer#trl.SFTTrainer) prend entièrement en charge l’entraînement des modèles Vision-Language (VLM). Pour entraîner un VLM, fournissez un jeu de données contenant soit une colonne `image` (une image par exemple), soit une colonne `images` (liste d’images par exemple). Pour plus d’informations sur la structure attendue du jeu de données, consultez la section [Format du jeu de données — Jeu de données Vision](dataset_formats#vision-dataset). Un exemple de tel jeu de données est [LLaVA Instruct Mix](https://huggingface.co/datasets/trl-lib/llava-instruct-mix).

```python
from trl import SFTConfig, SFTTrainer
from datasets import load_dataset

trainer = SFTTrainer(
    model="Qwen/Qwen2.5-VL-3B-Instruct",
    args=SFTConfig(max_length=None),
    train_dataset=load_dataset("trl-lib/llava-instruct-mix", split="train"),
)
trainer.train()
```

> [!TIP]
> Pour les VLM, la troncature peut supprimer des jetons d’image, ce qui entraîne des erreurs lors de l’entraînement. Pour éviter cela, définissez `max_length=None` dans [SFTConfig](/docs/trl/v1.18.2/fr/sft_trainer#trl.SFTConfig). Cela permet au modèle de traiter la longueur complète de la séquence sans tronquer les jetons d’image.
>
> ```python
> SFTConfig(max_length=None, ...)
> ```
>
> N'utilisez `max_length` que si vous avez vérifié que la troncature ne supprimera pas les jetons d'image pour l'ensemble du jeu de données.

## SFTTrainer[[trl.SFTTrainer]]

#### trl.SFTTrainer[[trl.SFTTrainer]]

```python
trl.SFTTrainer(model: str | PreTrainedModel | PeftModel, args: trl.trainer.sft_config.SFTConfig | transformers.training_args.TrainingArguments | None = None, data_collator: collections.abc.Callable[[list[typing.Any]], dict[str, typing.Any]] | None = None, train_dataset: datasets.arrow_dataset.Dataset | datasets.iterable_dataset.IterableDataset | None = None, eval_dataset: datasets.arrow_dataset.Dataset | datasets.iterable_dataset.IterableDataset | datasets.dataset_dict.DatasetDict | datasets.dataset_dict.IterableDatasetDict | dict[str, datasets.arrow_dataset.Dataset | datasets.iterable_dataset.IterableDataset] | None = None, processing_class: transformers.tokenization_utils_base.PreTrainedTokenizerBase | transformers.processing_utils.ProcessorMixin | None = None, compute_loss_func: collections.abc.Callable | None = None, compute_metrics: collections.abc.Callable[[transformers.trainer_utils.EvalPrediction], dict] | None = None, callbacks: list[transformers.trainer_callback.TrainerCallback] | None = None, optimizers: tuple[typing.Optional[torch.optim.Optimizer], typing.Optional[torch.optim.lr_scheduler.LambdaLR]] = (None, None), optimizer_cls_and_kwargs: tuple[type[torch.optim.Optimizer], dict[str, typing.Any]] | None = None, preprocess_logits_for_metrics: collections.abc.Callable[[torch.Tensor, torch.Tensor], torch.Tensor] | None = None, quantization_config: BitsAndBytesConfig | None = None, peft_config: PeftConfig | None = None, formatting_func: collections.abc.Callable[[dict], str] | None = None)
```

[Source](https://github.com/huggingface/trl/blob/v1.18.2/trl/trainer/sft_trainer.py#L517)

**Paramètres :**

model (`str` ou [PreTrainedModel](https://huggingface.co/docs/transformers/v5.23.0/en/main_classes/model#transformers.PreTrainedModel) ou [PeftModel](https://huggingface.co/docs/peft/v0.22.0/en/package_reference/peft_model#peft.PeftModel)) : Modèle à entraîner. Peut être :  - Une chaîne de caractères, correspondant à l'*identifiant du modèle* d'un modèle pré-entraîné hébergé dans un dépôt de modèles sur huggingface.co, ou un chemin vers un *dossier* contenant les poids du modèle enregistrés à l'aide de [save_pretrained](https://huggingface.co/docs/transformers/v5.23.0/en/main_classes/model#transformers.PreTrainedModel.save_pretrained), par exemple `'./my_model_directory/'`. Le modèle est chargé à l'aide de `<ModelArchitecture>.from_pretrained` (où `<ModelArchitecture>` est dérivé de la configuration du modèle) avec les arguments nommés de `args.model_init_kwargs`. Si `dtype` n'est pas spécifié dans `args.model_init_kwargs`, la valeur par défaut est `float32`. Cela diffère de [from_pretrained](https://huggingface.co/docs/transformers/v5.23.0/en/main_classes/model#transformers.PreTrainedModel.from_pretrained), où (depuis Transformers v5) le type de données est déduit de la configuration du modèle. - Un objet [PreTrainedModel](https://huggingface.co/docs/transformers/v5.23.0/en/main_classes/model#transformers.PreTrainedModel). Seuls les modèles de langage causaux sont pris en charge. - Un objet [PeftModel](https://huggingface.co/docs/peft/v0.22.0/en/package_reference/peft_model#peft.PeftModel). Seuls les modèles de langage causaux sont pris en charge.

args ([SFTConfig](/docs/trl/v1.18.2/fr/sft_trainer#trl.SFTConfig), *facultatif*) : Configuration pour cet entraîneur. Si `None`, une configuration par défaut est utilisée.

data_collator (`DataCollator`, *facultatif*) : Fonction à utiliser pour former un lot à partir d'une liste d'éléments du `train_dataset` ou du `eval_dataset` traités. Par défaut, elle est définie sur `DataCollatorForLanguageModeling`, ou sur `DataCollatorForVisionLanguageModeling` si le jeu de données contient des images.

train_dataset ([Dataset](https://huggingface.co/docs/datasets/v5.2.0/en/package_reference/main_classes#datasets.Dataset) ou [IterableDataset](https://huggingface.co/docs/datasets/v5.2.0/en/package_reference/main_classes#datasets.IterableDataset)) : Jeu de données à utiliser pour l'entraînement. Cet entraîneur prend en charge les types [language modeling](#language-modeling) et [prompt-completion](#prompt-completion). Le format des échantillons peut être : - [Standard](dataset_formats#standard) : chaque échantillon contient du texte brut. - [Conversational](dataset_formats#conversational) : chaque échantillon contient des messages structurés (par exemple, rôle et contenu). L'entraîneur prend également en charge les jeux de données pré-tokenisés, reconnus par une colonne `input_ids` obligatoire. Une colonne `labels` facultative (`-100` sur les jetons exclus de la perte) est utilisée telle quelle si elle est présente ; sinon, les étiquettes sont construites à partir des colonnes facultatives `assistant_masks` / `completion_mask` (qui sont ensuite intégrées puis supprimées, `completion_mask` uniquement lorsque `completion_only_loss=True`), ou par défaut à partir d'une copie de `input_ids`. Les séquences sont tronquées à `max_length` lors de la préparation. Avec `skip_prepare_dataset=True`, la préparation est ignorée et le collateur est censé gérer le jeu de données tel quel. Lorsque `train_dataset` est un [IterableDataset](https://huggingface.co/docs/datasets/v5.2.0/en/package_reference/main_classes#datasets.IterableDataset) (par exemple, un jeu de données en flux), `max_steps` doit être défini dans les arguments d'entraînement, car sa longueur ne peut pas être déduite et le nombre total d'étapes d'entraînement est nécessaire pour limiter la boucle d'entraînement et configurer le planificateur de taux d'apprentissage.

eval_dataset ([Dataset](https://huggingface.co/docs/datasets/v5.2.0/en/package_reference/main_classes#datasets.Dataset), [IterableDataset](https://huggingface.co/docs/datasets/v5.2.0/en/package_reference/main_classes#datasets.IterableDataset), [DatasetDict](https://huggingface.co/docs/datasets/v5.2.0/en/package_reference/main_classes#datasets.DatasetDict), [IterableDatasetDict](https://huggingface.co/docs/datasets/v5.2.0/en/package_reference/main_classes#datasets.IterableDatasetDict) ou `dict[str, Dataset | IterableDataset]`) : Jeu de données à utiliser pour l'évaluation. Il doit répondre aux mêmes exigences que `train_dataset`.

processing_class ([PreTrainedTokenizerBase](https://huggingface.co/docs/transformers/v5.23.0/en/internal/tokenization_utils#transformers.PreTrainedTokenizerBase), [ProcessorMixin](https://huggingface.co/docs/transformers/v5.23.0/en/main_classes/processors#transformers.ProcessorMixin), *facultatif*) : classe de traitement utilisée pour traiter les données. Si `None`, la classe de traitement est chargée à partir du nom du modèle avec [from_pretrained](https://huggingface.co/docs/transformers/v5.23.0/en/model_doc/auto#transformers.AutoProcessor.from_pretrained). Un jeton de bourrage, `tokenizer.pad_token`, doit être défini. Si la classe de traitement n'a pas défini de jeton de bourrage, `tokenizer.eos_token` sera utilisé par défaut.

compute_loss_func (`Callable`, *facultatif*) : une fonction qui accepte les sorties du modèle, les étiquettes et le nombre d'éléments dans le lot accumulé entier (batch_size * gradient_accumulation_steps) et renvoie la perte. Cette option est obsolète et sera supprimée dans la v2.0.0 : sous-classez [SFTTrainer](/docs/trl/v1.18.2/fr/sft_trainer#trl.SFTTrainer) et écrasez `compute_loss` à la place.

compute_metrics (`Callable[[EvalPrediction], dict]`, *facultatif*) : La fonction qui sera utilisée pour calculer les métriques lors de l'évaluation. Elle doit prendre un [EvalPrediction](https://huggingface.co/docs/transformers/v5.23.0/en/internal/trainer_utils#transformers.EvalPrediction) en entrée et renvoyer un dictionnaire associant des chaînes de caractères aux valeurs des métriques. Lors du passage de [SFTConfig](/docs/trl/v1.18.2/fr/sft_trainer#trl.SFTConfig) avec `batch_eval_metrics` défini sur `True`, votre fonction `compute_metrics` doit prendre un argument booléen `compute_result`. Cela sera déclenché après le dernier lot d'évaluation pour indiquer que la fonction doit calculer et renvoyer les statistiques globales de synthèse plutôt que d'accumuler les statistiques au niveau du lot. Les logits qu'elle reçoit sont recalculés lors d'un passage avant supplémentaire. Cette fonctionnalité est obsolète et sera supprimée dans la v2.0.0.

callbacks (liste de [TrainerCallback](https://huggingface.co/docs/transformers/v5.23.0/en/main_classes/callback#transformers.TrainerCallback), *facultatif*) : Liste de callbacks pour personnaliser la boucle d'entraînement. Ils seront ajoutés à la liste des callbacks par défaut détaillée [ici](https://huggingface.co/docs/transformers/main_classes/callback). Si vous souhaitez supprimer l'un des callbacks par défaut utilisés, utilisez la méthode [remove_callback](https://huggingface.co/docs/transformers/v5.23.0/en/main_classes/trainer#transformers.Trainer.remove_callback).

optimizers (`tuple[torch.optim.Optimizer | None, torch.optim.lr_scheduler.LambdaLR | None]`, *facultatif*, valeur par défaut `(None, None)`) : Un tuple contenant l'optimiseur et le planificateur à utiliser. Par défaut, une instance de `AdamW` est appliquée à votre modèle, ainsi qu'un planificateur défini par [get_linear_schedule_with_warmup](https://huggingface.co/docs/transformers/v5.23.0/en/main_classes/optimizer_schedules#transformers.get_linear_schedule_with_warmup) et contrôlé par `args`.

optimizer_cls_and_kwargs (`tuple[Type[torch.optim.Optimizer], Dict[str, Any]]`, *facultatif*) : Un tuple contenant la classe d'optimiseur et les arguments nommés à utiliser. Remplace `optim` et `optim_args` dans `args`. Incompatible avec l'argument `optimizers`. Contrairement à `optimizers`, cet argument évite d'avoir à placer les paramètres du modèle sur les bons appareils avant d'initialiser le Trainer.

preprocess_logits_for_metrics (`Callable[[torch.Tensor, torch.Tensor], torch.Tensor]`, *facultatif*) : une fonction qui prétraite les logits juste avant de les mettre en cache à chaque étape d'évaluation. Elle doit prendre deux tenseurs en entrée, les logits et les étiquettes, et renvoyer les logits une fois traités comme souhaité. Les modifications apportées par cette fonction seront reflétées dans les prédictions reçues par `compute_metrics`. Notez que les étiquettes (deuxième paramètre) seront `None` si le jeu de données ne les contient pas.

quantization_config ([BitsAndBytesConfig](https://huggingface.co/docs/transformers/v5.23.0/en/main_classes/quantization#transformers.BitsAndBytesConfig), *facultatif*) : Configuration de quantification utilisée lors du chargement du modèle à partir d'un identifiant de modèle. À combiner avec `peft_config` pour l'entraînement QLoRA. Ignorée si le modèle est déjà instancié.

peft_config ([PeftConfig](https://huggingface.co/docs/peft/v0.22.0/en/package_reference/config#peft.PeftConfig), *facultatif*) : configuration PEFT utilisée pour envelopper le modèle. Si `None`, le modèle n'est pas enveloppé.

formatting_func (`Callable`, *facultatif*) : fonction de mise en forme appliquée au jeu de données avant la tokenisation. L'application explicite de la fonction de mise en forme convertit le jeu de données en type [language modeling](#language-modeling).

Trainer pour la méthode de Fine-Tuning Supervisé (SFT).

Cette classe est un wrapper autour de la classe [Trainer](https://huggingface.co/docs/transformers/v5.23.0/en/main_classes/trainer#transformers.Trainer) et hérite de tous ses attributs et méthodes.

Exemple :

```python
>>> from trl import SFTTrainer
>>> from datasets import load_dataset

>>> dataset = load_dataset("roneneldan/TinyStories", split="train[:1%]")

>>> trainer = SFTTrainer(
...     model="Qwen/Qwen2.5-0.5B-Instruct",
...     train_dataset=dataset,
... )
>>> trainer.train()
```

#### train[[trl.SFTTrainer.train]]

```python
train(resume_from_checkpoint: str | bool | None = None, trial: optuna.Trial | dict[str, Any] | None = None, ignore_keys_for_eval: list[str] | None = None)
```

[Source](https://github.com/huggingface/trl/blob/v1.18.2/transformers/trainer.py#L1450)

**Paramètres :**

resume_from_checkpoint (`str` ou `bool`, *facultatif*) : Si c'est une `str`, chemin local d'un point de contrôle enregistré par une instance précédente de `Trainer`. Si c'est un `bool` et vaut `True`, charge le dernier point de contrôle dans *args.output_dir* tel qu'enregistré par une instance précédente de `Trainer`. S'il est présent, l'entraînement reprendra à partir des états du modèle/optimiseur/planificateur chargés ici.

trial (`optuna.Trial` ou `dict[str, Any]`, *facultatif*) : L'exécution de l'essai ou le dictionnaire d'hyperparamètres pour la recherche d'hyperparamètres.

ignore_keys_for_eval (`list[str]`, *facultatif*) : Une liste de clés dans la sortie de votre modèle (s'il s'agit d'un dictionnaire) qui doivent être ignorées lors de la collecte des prédictions pour l'évaluation pendant l'entraînement.

**Retourne :** `~trainer_utils.TrainOutput`

Objet contenant le nombre d'étapes globales, la perte d'entraînement et les métriques.

Point d'entrée principal de l'entraînement.

#### save_model[[trl.SFTTrainer.save_model]]

```python
save_model(output_dir: str | None = None, _internal_call: bool = False)
```

[Source](https://github.com/huggingface/trl/blob/v1.18.2/transformers/trainer.py#L4077)

Enregistrera le modèle, ce qui vous permettra de le recharger à l'aide de `from_pretrained()`.

N'enregistrera que depuis le processus principal.

#### push_to_hub[[trl.SFTTrainer.push_to_hub]]

```python
push_to_hub(commit_message: str | None = 'End of training', blocking: bool = True, token: str | None = None, revision: str | None = None, private: bool | None = None, **kwargs)
```

[Source](https://github.com/huggingface/trl/blob/v1.18.2/transformers/trainer.py#L4337)

**Paramètres :**

commit_message (`str`, *facultatif*, par défaut `"End of training"`) : Message à commiter lors de la poussée.

blocking (`bool`, *facultatif*, par défaut `True`) : Indique si la fonction doit ne renvoyer un résultat qu'une fois le `git push` terminé.

token (`str`, *facultatif*, valeur par défaut `None`) : Jeton avec permission d'écriture pour écraser les arguments d'origine du Trainer.

revision (`str`, *facultatif*) : La révision git à partir de laquelle effectuer le commit. Par défaut, il s'agit de la tête de la branche "main".

private (`bool`, *facultatif*) : Indique s'il faut rendre le dépôt privé lors de sa création. La valeur par défaut est `args.hub_private_repo`. N'a aucun effet si le dépôt existe déjà.

kwargs (`dict[str, Any]`, *facultatif*) : Arguments supplémentaires passés à `~Trainer.create_model_card`.

**Retourne :**

L'URL du dépôt où le modèle a été poussé si `blocking=False`, ou un objet `Future` suivant la progression de l'engagement si `blocking=True`.

Téléchargez `self.model` et `self.processing_class` sur le hub de modèles 🤗 dans le dépôt `self.args.hub_model_id`.

## SFTConfig[[trl.SFTConfig]]

#### trl.SFTConfig[[trl.SFTConfig]]

```python
trl.SFTConfig(output_dir: str | None = None, per_device_train_batch_size: int = 8, num_train_epochs: float = 3.0, max_steps: int = -1, learning_rate: float = 2e-05, lr_scheduler_type: transformers.trainer_utils.SchedulerType | str = 'linear', lr_scheduler_kwargs: dict | str | None = None, warmup_steps: float = 0, optim: transformers.training_args.OptimizerNames | str = 'adamw_torch_fused', optim_args: str | None = None, weight_decay: float = 0.0, adam_beta1: float = 0.9, adam_beta2: float = 0.999, adam_epsilon: float = 1e-08, optim_target_modules: None | str | list[str] = None, gradient_accumulation_steps: int = 1, average_tokens_across_devices: bool = True, max_grad_norm: float = 1.0, label_smoothing_factor: float = 0.0, bf16: bool | None = None, fp16: bool = False, bf16_full_eval: bool = False, fp16_full_eval: bool = False, tf32: bool | None = None, activation_checkpointing: bool | None = None, activation_checkpointing_kwargs: dict[str, typing.Any] | str | None = None, gradient_checkpointing: bool | None = None, gradient_checkpointing_kwargs: dict[str, typing.Any] | str | None = None, torch_compile: bool = False, torch_compile_backend: str | None = None, torch_compile_mode: str | None = None, use_liger_kernel: bool = False, liger_kernel_config: dict[str, bool] | None = None, use_cache: bool = False, neftune_noise_alpha: float | None = None, torch_empty_cache_steps: int | None = None, auto_find_batch_size: bool = False, logging_strategy: transformers.trainer_utils.IntervalStrategy | str = 'steps', logging_steps: float = 10, logging_first_step: bool = False, log_on_each_node: bool = True, logging_nan_inf_filter: bool = True, include_num_input_tokens_seen: str | bool = 'no', log_level: str = 'passive', log_level_replica: str = 'warning', disable_tqdm: bool | None = None, report_to: None | str | list[str] = 'none', run_name: str | None = None, project: str = 'huggingface', trackio_space_id: str | None = None, trackio_bucket_id: str | None = None, trackio_static_space_id: typing.Union[str, NoneType, typing.Literal[False]] = None, eval_strategy: transformers.trainer_utils.IntervalStrategy | str = 'no', eval_steps: float | None = None, eval_delay: float = 0, per_device_eval_batch_size: int = 8, prediction_loss_only: bool = False, eval_on_start: bool = False, eval_do_concat_batches: bool = True, eval_use_gather_object: bool = False, eval_accumulation_steps: int | None = None, include_for_metrics: list[str] = <factory>, batch_eval_metrics: bool = False, save_only_model: bool = False, save_strategy: transformers.trainer_utils.SaveStrategy | str = 'steps', save_steps: float = 500, save_on_each_node: bool = False, save_total_limit: int | None = None, enable_jit_checkpoint: bool = False, push_to_hub: bool = False, hub_token: str | None = None, hub_private_repo: bool | None = None, hub_model_id: str | None = None, hub_strategy: transformers.trainer_utils.HubStrategy | str = 'every_save', hub_always_push: bool = False, hub_revision: str | None = None, load_best_model_at_end: bool = False, metric_for_best_model: str | None = None, greater_is_better: bool | None = None, ignore_data_skip: bool = False, restore_callback_states_from_checkpoint: bool = False, full_determinism: bool = False, seed: int = 42, data_seed: int | None = None, use_cpu: bool = False, accelerator_config: dict | str | None = None, parallelism_config: accelerate.parallelism_config.ParallelismConfig | None = None, dataloader_drop_last: bool = False, dataloader_num_workers: int = 0, dataloader_pin_memory: bool = True, dataloader_persistent_workers: bool = False, dataloader_prefetch_factor: int | None = None, dataloader_multiprocessing_context: str | None = None, dataloader_in_order: bool = True, remove_unused_columns: bool = True, label_names: list[str] | None = None, train_sampling_strategy: str = 'random', length_column_name: str = 'length', ddp_find_unused_parameters: bool | None = None, ddp_bucket_cap_mb: int | None = None, ddp_broadcast_buffers: bool | None = None, ddp_static_graph: bool | None = None, ddp_backend: str | None = None, ddp_timeout: int = 1800, fsdp: str | None = None, fsdp_config: dict[str, typing.Any] | str | None = None, deepspeed: dict | str | None = None, debug: str | list[transformers.debug_utils.DebugOption] = '', skip_memory_metrics: bool = True, do_train: bool = False, do_eval: bool = False, do_predict: bool = False, resume_from_checkpoint: str | None = None, local_rank: int = -1, model_init_kwargs: dict[str, typing.Any] | str | None = None, trust_remote_code: bool = False, router_aux_loss_coef: float | None = None, chat_template_path: str | None = None, dataset_text_field: str = 'text', dataset_kwargs: dict[str, typing.Any] | str | None = None, dataset_num_proc: int | None = None, eos_token: str | None = None, max_length: int | None = 1024, truncation_mode: str = 'keep_start', shuffle_dataset: bool = False, packing: bool = False, packing_strategy: str = 'bfd', padding_free: bool = False, pad_to_multiple_of: int | str | None = 'auto', eval_packing: bool | None = None, completion_only_loss: bool | None = None, assistant_only_loss: bool = False, loss_type: str = 'nll', activation_offloading: bool = False, pad_token: str | None = None)
```

[Source](https://github.com/huggingface/trl/blob/v1.18.2/trl/trainer/sft_config.py#L23)

**Paramètres qui contrôlent le modèle :**

model_init_kwargs (`dict[str, Any]`, *facultatif*) : Arguments nommés pour [from_pretrained](https://huggingface.co/docs/transformers/v5.23.0/en/model_doc/auto#transformers.AutoModelForCausalLM.from_pretrained), utilisés lorsque l'argument `model` du [SFTTrainer](/docs/trl/v1.18.2/fr/sft_trainer#trl.SFTTrainer) est fourni sous forme de chaîne de caractères. La valeur de `revision` est également utilisée lors du chargement de la classe de traitement.

trust_remote_code (`bool`, *facultatif*, par défaut `False`) : Indique s'il faut autoriser le chargement de modèles et de tokenizers qui incluent du code Python personnalisé depuis le Hub. Transmis à [from_pretrained](https://huggingface.co/docs/transformers/v5.23.0/en/model_doc/auto#transformers.AutoModelForCausalLM.from_pretrained) et [from_pretrained](https://huggingface.co/docs/transformers/v5.23.0/en/model_doc/auto#transformers.AutoProcessor.from_pretrained).

router_aux_loss_coef (`float`, *facultatif*) : Coefficient de la perte auxiliaire d'équilibrage de charge pour les modèles Mixture-of-Experts (MoE), ajoutée à la perte d'entraînement avec ce poids. Si non défini, la valeur déclarée par la configuration du modèle est utilisée. Définissez-le sur `0.0` pour le désactiver. Échoue s'il est utilisé avec un modèle non-MoE.

chat_template_path (`str`, *facultatif*) : Si spécifié, définit le modèle de chat du modèle. Il peut s'agir du chemin vers un tokenizer (répertoire local ou modèle du Hugging Face Hub) ou d'un chemin direct vers un fichier de modèle Jinja. Lors de l'utilisation d'un fichier Jinja, vous devez vous assurer que les jetons spéciaux référencés dans le modèle sont ajoutés au tokenizer et que la couche d'incorporation du modèle est redimensionnée en conséquence.

**Paramètres qui contrôlent le prétraitement des données :**

dataset_text_field (`str`, *facultatif*, valeur par défaut `"text"`) : Nom de la colonne contenant les données textuelles dans le jeu de données.

dataset_kwargs (`dict[str, Any]`, *facultatif*) : Dictionnaire des arguments optionnels par mot-clé pour la préparation du jeu de données. La seule clé prise en charge est `skip_prepare_dataset`. Lorsque le jeu de données contient des images, `skip_prepare_dataset` est automatiquement traité comme `True`, quelle que soit la valeur fournie, car le prétraitement est effectué à la volée.

dataset_num_proc (`int`, *facultatif*) : Nombre de processus à utiliser pour le traitement du jeu de données.

eos_token (`str`, *facultatif*) : Jeton utilisé pour indiquer la fin d'un tour ou d'une séquence. Si `None`, la valeur par défaut est `processing_class.eos_token`.

max_length (`int` ou `None`, *facultatif*, par défaut `1024`) : Longueur maximale de la séquence tokenisée. Les séquences plus longues que `max_length` sont tronquées à gauche ou à droite selon `truncation_mode`. Si `None`, aucun tronquage n’est appliqué. Lorsque le packing est activé, cette valeur définit la longueur de la séquence.

truncation_mode (`str`, *facultatif*, par défaut `"keep_start"`) : Mode de troncature à utiliser lorsque la séquence dépasse `max_length`. La seule valeur prise en charge est `"keep_start"`. La valeur `"keep_end"` est obsolète et sera supprimée dans la v2.0.0.

shuffle_dataset (`bool`, *facultatif*, par défaut `False`) : Indique s'il faut mélanger le jeu de données.

packing (`bool`, *facultatif*, valeur par défaut `False`) : Indique s'il faut regrouper plusieurs séquences en blocs de longueur fixe afin d'améliorer l'efficacité computationnelle et de réduire le bourrage (padding). Utilise `max_length` pour définir la longueur des séquences.

packing_strategy (`str`, *facultatif*, par défaut `"bfd"`) : Stratégie pour l’empaquetage des séquences. Peut être `"bfd"` (best-fit decreasing, tronque le débordement), `"bfd_split"` (best-fit decreasing, divise les séquences en débordement) ou `"wrapped"` (agressif, coupe en pleine séquence).

padding_free (`bool`, *facultatif*, valeur par défaut `False`) : Indique s'il faut effectuer des passes avant sans bourrage (padding) en aplatissant toutes les séquences du lot en une seule séquence continue. Cela réduit l'utilisation de la mémoire en éliminant le surcoût lié au bourrage. Actuellement, cette fonctionnalité n'est prise en charge qu'avec FlashAttention 2 ou 3, qui peuvent traiter efficacement la structure de lot aplatie. Lorsque le regroupement (packing) est activé avec la stratégie `"bfd"`, le mode sans bourrage est activé, indépendamment de la valeur de ce paramètre.

pad_to_multiple_of (`int` ou `str`, *facultatif*, valeur par défaut `"auto"`) : Si défini, les séquences seront remplies jusqu'à un multiple de cette valeur. `"auto"` remplit jusqu'à un multiple de 128 sur Neuron (AWS Trainium), qui compile une fois par forme d'entrée, et ne remplit pas ailleurs.

eval_packing (`bool`, *facultatif*) : Indique s'il faut regrouper le jeu de données d'évaluation. Si `None`, utilise la même valeur que `packing`.

**Paramètres qui contrôlent l’entraînement :**

completion_only_loss (`bool`, *facultatif*) : Indique s'il faut calculer la perte uniquement sur la partie complétion de la séquence. Si défini sur `True`, la perte est calculée uniquement sur la complétion, ce qui n'est pris en charge que pour les jeux de données [prompt-completion](#prompt-completion). Si `False`, la perte est calculée sur l'ensemble de la séquence. Si `None` (par défaut), le comportement dépend du jeu de données : la perte est calculée sur la complétion pour les jeux de données [prompt-completion](#prompt-completion), et sur la séquence complète pour les jeux de données de [language modeling](#language-modeling).

assistant_only_loss (`bool`, *facultatif*, valeur par défaut `False`) : Indique s'il faut calculer la perte uniquement sur la partie assistant de la séquence. Si défini sur `True`, la perte est calculée uniquement sur les réponses de l'assistant, ce qui n'est pris en charge que pour les jeux de données [conversationnels](#conversational). Si `False`, la perte est calculée sur l'ensemble de la séquence.

loss_type (`str`, *facultatif*, par défaut `"nll"`) : Type de perte à utiliser. Les valeurs possibles sont :  - `"nll"` : négative de log-vraisemblance standard. - `"dft"` : Dynamic Fine-Tuning, tel que décrit dans [cet article](https://huggingface.co/papers/2508.05629). - `"chunked_nll"` : alias obsolète de `"nll"`, qui calcule la perte de la même manière. Il sera supprimé dans la v2.0.0.

activation_offloading (`bool`, *facultatif*, par défaut `False`) : Indique s'il faut décharger les activations sur le CPU.

**Paramètres obsolètes :**

pad_token :   Le paramètre `pad_token` est obsolète et sera supprimé dans la version v2.0.0. Définissez directement `tokenizer.pad_token` et passez-le en tant que `processing_class` au formateur à la place.

Classe de configuration pour le [SFTTrainer](/docs/trl/v1.18.2/fr/sft_trainer#trl.SFTTrainer).

Cette classe ne contient que les paramètres spécifiques à l’entraînement SFT. Pour la liste complète des arguments d’entraînement, veuillez consulter la documentation de [TrainingArguments](https://huggingface.co/docs/transformers/v5.23.0/en/main_classes/trainer#transformers.TrainingArguments). Notez que les valeurs par défaut de cette classe peuvent différer de celles de [TrainingArguments](https://huggingface.co/docs/transformers/v5.23.0/en/main_classes/trainer#transformers.TrainingArguments).

À l’aide de [HfArgumentParser](https://huggingface.co/docs/transformers/v5.23.0/en/internal/trainer_utils#transformers.HfArgumentParser), nous pouvons transformer cette classe en arguments [argparse](https://docs.python.org/3/library/argparse#module-argparse) qui peuvent être spécifiés sur la ligne de commande.

> [!NOTE]
> Ces paramètres ont des valeurs par défaut différentes de [TrainingArguments](https://huggingface.co/docs/transformers/v5.23.0/en/main_classes/trainer#transformers.TrainingArguments) : - `logging_steps` : la valeur par défaut est `10` au lieu de `500`. - `gradient_checkpointing` : la valeur par défaut est `True` au lieu de `False`. - `bf16` : la valeur par défaut est `True` si `fp16` n'est pas défini, au lieu de `False`. - `learning_rate` : la valeur par défaut est `2e-5` au lieu de `5e-5`.

