# Fine-tuning à partir du dernier checkpoint

Vous devez modifier le `Trainer` d'abord pour ajouter `save_strategy` et `save_steps`. Ci-dessous enregistre un checkpoint toutes les 50 étapes dans le dossier `outputs`.

```python
trainer = SFTTrainer(
    ....
    train_dataset = dataset,
        ....
        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 reprendra depuis le dernier checkpoint et continuera l'entraînement.

### Intégration 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"
```

Ensuite dans `TrainingArguments()` définissez

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

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 Early Stopping ?

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

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

```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 checkpoints sauvegardés pour l'arrêt précoce
        save_strategy = "steps",             # sauvegarder le modèle toutes les N étapes
        save_steps = 10,                     # combien d'étapes avant de sauvegarder le modèle
        save_total_limit = 3,                # ne conserver que 3 checkpoints sauvegardés pour économiser de l'espace disque
        eval_strategy = "steps",             # évaluer toutes les N étapes
        eval_steps = 10,                     # combien d'étapes avant de faire l'évaluation
        load_best_model_at_end = True,       # DOIT ÊTRE UTILISÉ pour l'arrêt précoce
        metric_for_best_model = "eval_loss", # métrique sur laquelle nous voulons effectuer l'arrêt précoce
        greater_is_better = False,           # plus la perte d'éval est faible, mieux c'est
    ),
    trainer = Trainer(
    tokenizer = tokenizer,
    train_dataset = new_dataset["train"],
    eval_dataset = new_dataset["test"],
)
```

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

```python
from transformers import EarlyStoppingCallback
early_stopping_callback = EarlyStoppingCallback(
    early_stopping_patience = 3,     # Combien d'étapes nous attendrons si la perte d'éval ne diminue pas
                                     # Par exemple la perte peut augmenter, mais diminuer après 3 étapes
    early_stopping_threshold = 0.0,  # Peut être réglé plus haut - définit de combien la perte doit diminuer avant
                                     # que nous considérions l'arrêt précoce. Par ex. 0.01 signifie si la perte était
                                     # 0.02 puis 0.01, nous envisageons d'arrêter prématurément l'exécution.
)
trainer.add_callback(early_stopping_callback)
```

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