# Affinage à partir du dernier checkpoint

Vous devez modifier le `Trainer` d’abord pour ajouter `save_strategy` et `save_steps`. Ci-dessous enregistre un point de contrôle toutes les 50 étapes dans le dossier `outputs`.

```python
trainer = SFTTrainer(
    ....
    args = TrainingArguments(
        ....
        output_dir = "outputs",
        save_strategy = "steps",
        save_steps = 50,
    ),
)
```

Ensuite, dans le trainer, faites :

```python
trainer_stats = trainer.train(resume_from_checkpoint = True)
```

Ce qui démarrera à partir du dernier point de contrôle et poursuivra l’entraînement.

### Intégration de Wandb

```
# Installer la bibliothèque
!pip install wandb --upgrade

# Configuration de Wandb
!wandb login <token>

import os

os.environ["WANDB_PROJECT"] = "<name>"
os.environ["WANDB_LOG_MODEL"] = "checkpoint"
```

Puis dans `TrainingArguments()` définissez

```
report_to = "wandb",
logging_steps = 1, # Modifier si nécessaire
save_steps = 100 # Modifier si nécessaire
run_name = "<name>" # (Facultatif)
```

Pour entraîner le modèle, faites `trainer.train()`; pour reprendre l’entraînement, faites

```
import wandb
run = wandb.init()
artifact = run.use_artifact('<username>/<Wandb-project-name>/<run-id>', type='model')
artifact_dir = artifact.download()
trainer.train(resume_from_checkpoint=artifact_dir)
```

## :question:Comment faire un arrêt anticipé ?

Si vous voulez arrêter ou mettre en pause l’exécution du fine-tuning / de l’entraînement parce que la perte de validation ne diminue pas, vous pouvez utiliser l’arrêt anticipé, qui arrête le processus d’entraînement. Utilisez `EarlyStoppingCallback`.

Comme d’habitude, configurez votre trainer et votre jeu de données de validation. Ce qui suit est utilisé pour arrêter l’entraînement si le `eval_loss` (la perte de validation) ne diminue pas après 3 étapes environ.

```python
from trl import SFTConfig, SFTTrainer
trainer = SFTTrainer(
    args = SFTConfig(
        fp16_full_eval = True,
        per_device_eval_batch_size = 2,
        eval_accumulation_steps = 4,
        output_dir = "training_checkpoints", # emplacement des points de contrôle enregistrés pour l’arrêt anticipé
        save_strategy = "steps",             # enregistrer le modèle toutes les N étapes
        save_steps = 10,                     # nombre d’étapes avant d’enregistrer le modèle
        save_total_limit = 3,                # conserver seulement 3 points de contrôle enregistrés pour économiser de l’espace disque
        eval_strategy = "steps",             # évaluer toutes les N étapes
        eval_steps = 10,                     # nombre d’étapes avant d’effectuer l’évaluation
        load_best_model_at_end = True,       # DOIT ÊTRE UTILISÉ pour l’arrêt anticipé
        metric_for_best_model = "eval_loss", # métrique sur laquelle nous voulons baser l’arrêt anticipé
        greater_is_better = False,           # plus la perte de validation est faible, mieux c’est
    ),
    model = model,
    tokenizer = tokenizer,
    train_dataset = new_dataset["train"],
    eval_dataset = new_dataset["test"],
)
```

Nous ajoutons ensuite le callback, qui peut aussi être personnalisé :

```python
from transformers import EarlyStoppingCallback
early_stopping_callback = EarlyStoppingCallback(
    early_stopping_patience = 3,     # Combien d’étapes nous attendrons si la perte de validation ne diminue pas
                                     # Par exemple, la perte pourrait augmenter, puis diminuer après 3 étapes
    early_stopping_threshold = 0.0,  # Peut être défini plus haut - définit de combien la perte doit diminuer avant
                                     # que nous considérions l’arrêt anticipé. Par exemple, 0.01 signifie que si la perte était
                                     # de 0.02 puis 0.01, nous considérons qu’il faut arrêter l’exécution de manière anticipée.
)
trainer.add_callback(early_stopping_callback)
```

Puis entraînez le modèle comme d’habitude via `trainer.train() .`


---

# Agent Instructions: Querying This Documentation

If you need additional information that is not directly available in this page, you can query the documentation dynamically by asking a question.

Perform an HTTP GET request on the current page URL with the `ask` query parameter:

```
GET https://unsloth.ai/docs/fr/bases/finetuning-from-last-checkpoint.md?ask=<question>
```

The question should be specific, self-contained, and written in natural language.
The response will contain a direct answer to the question and relevant excerpts and sources from the documentation.

Use this mechanism when the answer is not explicitly present in the current page, you need clarification or additional context, or you want to retrieve related documentation sections.