Passer au contenu principal
torchtune est une bibliothèque basée sur PyTorch conçue pour simplifier le développement, le Fine-tuning et l’expérimentation pour les grands modèles de langage (LLM). De plus, torchtune intègre une prise en charge native du logging avec W&B, ce qui améliore le suivi et la visualisation des processus d’entraînement.
tableau de bord d’entraînement de TorchTune
Consultez l’article de blog de W&B sur le Fine-tuning de Mistral 7B avec torchtune.

​
La journalisation W&B à portée de main

Redéfinissez les arguments de ligne de commande au lancement :
tune run lora_finetune_single_device --config llama3/8B_lora_single_device \
  metric_logger._component_=torchtune.utils.metric_logging.WandBLogger \
  metric_logger.project="llama3_lora" \
  log_every_n_steps=5

​
Utiliser le logger de métriques W&B

Activez la journalisation W&B dans le fichier de configuration de la recette en modifiant la section metric_logger. Remplacez _component_ par la classe torchtune.utils.metric_logging.WandBLogger. Vous pouvez également fournir un nom de project ainsi que log_every_n_steps pour personnaliser le comportement de journalisation. Vous pouvez aussi transmettre n’importe quels autres kwargs, comme vous le feriez avec la méthode wandb.init(). Par exemple, si vous travaillez au sein d’une équipe, vous pouvez passer l’argument entity à la classe WandBLogger pour indiquer le nom de l’équipe. 
# dans llama3/8B_lora_single_device.yaml
metric_logger:
  _component_: torchtune.utils.metric_logging.WandBLogger
  project: llama3_lora
  entity: my_project
  job_type: lora_finetune_single_device
  group: my_awesome_experiments
log_every_n_steps: 5

​
Qu’est-ce qui est enregistré ?

Vous pouvez explorer le tableau de bord W&B pour consulter les métriques enregistrées. Par défaut, W&B enregistre tous les hyperparamètres du fichier de configuration ainsi que les paramètres remplacés au lancement. W&B capture la configuration résolue dans l’onglet Aperçu. W&B stocke également la configuration au format YAML dans l’onglet Files.
Configuration TorchTune

​
Métriques enregistrées

Chaque recette a sa propre boucle d’entraînement. Consultez chaque recette pour voir ses métriques enregistrées, qui incluent par défaut les suivantes :
MetricDescription
lossLa perte du modèle
lrLe taux d’apprentissage
tokens_per_secondLe nombre de tokens par seconde du modèle
grad_normLa norme du gradient du modèle
global_stepCorrespond à l’étape actuelle dans la boucle d’entraînement. Tient compte de l’accumulation des gradients : en pratique, global_step est incrémenté à chaque pas de l’optimiseur, et le modèle n’est mis à jour qu’une fois tous les gradient_accumulation_steps.
global_step n’est pas identique au nombre d’étapes d’entraînement. Il correspond à l’étape actuelle dans la boucle d’entraînement. Il tient compte de l’accumulation des gradients : en pratique, chaque fois qu’un pas de l’optimiseur est effectué, global_step est incrémenté de 1. Par exemple, si le dataloader contient 10 lots, que le nombre d’étapes d’accumulation des gradients est de 2 et que l’entraînement s’exécute pendant 3 époques, l’optimiseur effectuera 15 pas ; dans ce cas, global_step ira de 1 à 15.
La conception épurée de torchtune permet d’ajouter facilement des métriques personnalisées ou de modifier les métriques existantes. Il suffit de modifier le fichier de recette correspondant. Par exemple, vous pouvez enregistrer current_epoch comme pourcentage du nombre total d’époques, comme suit : 
# dans la fonction `train.py` du fichier de recette
self._metric_logger.log_dict(
    {"current_epoch": self.epochs * self.global_step / self._steps_per_epoch},
    step=self.global_step,
)
Cette bibliothèque évolue rapidement, et les métriques actuelles peuvent changer. Si vous souhaitez ajouter une métrique personnalisée, vous devez modifier la recette et appeler la fonction correspondante de self._metric_logger.*.

​
Enregistrer et charger des points de contrôle

La bibliothèque torchtune prend en charge différents formats de point de contrôle. Selon l’origine du modèle que vous utilisez, vous devez utiliser la classe de checkpointer appropriée. Si vous souhaitez enregistrer les points de contrôle du modèle dans les W&B Artifacts, la solution la plus simple consiste à surcharger les fonctions save_checkpoint dans la recette correspondante. Voici un exemple montrant comment surcharger la fonction save_checkpoint pour enregistrer les points de contrôle du modèle dans W&B Artifacts. 
def save_checkpoint(self, epoch: int) -> None:
    ...
    ## Sauvegardons le point de contrôle dans W&B
    ## selon la classe Checkpointer, le fichier sera nommé différemment
    ## Voici un exemple pour le cas full_finetune
    checkpoint_file = Path.joinpath(
        self._checkpointer._output_dir, f"torchtune_model_{epoch}"
    ).with_suffix(".pt")
    wandb_artifact = wandb.Artifact(
        name=f"torchtune_model_{epoch}",
        type="model",
        # description du point de contrôle du modèle
        description="Model checkpoint",
        # vous pouvez ajouter toutes les métadonnées souhaitées sous forme de dict
        metadata={
            utils.SEED_KEY: self.seed,
            utils.EPOCHS_KEY: self.epochs_run,
            utils.TOTAL_EPOCHS_KEY: self.total_epochs,
            utils.MAX_STEPS_KEY: self.max_steps_per_epoch,
        },
    )
    wandb_artifact.add_file(checkpoint_file)
    wandb.log_artifact(wandb_artifact)