🏁Fine-tuning depuis le dernier checkpoint

Le checkpointing vous permet de sauvegarder votre progression de fine-tuning afin que vous puissiez la mettre en pause puis la reprendre.

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.

trainer = SFTTrainer(
    ....
    train_dataset = dataset,
        ....
        output_dir = "outputs",
        save_strategy = "steps",
        save_steps = 50,
    ),
)

Ensuite dans le trainer faites :

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)

❓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.

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é :

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() .