> ## Documentation Index
> Fetch the complete documentation index at: https://docs.wandb.ai/llms.txt
> Use this file to discover all available pages before exploring further.
# PyTorch torchtune
> Utilisez la journalisation W&B dans PyTorch torchtune pour suivre les expériences de fine-tuning de LLM avec le logger de métriques WandBLogger.
export const ColabLink = ({url}) =>
Essayer sur Colab
;
[torchtune](https://meta-pytorch.org/torchtune/stable/index.html) 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](https://meta-pytorch.org/torchtune/stable/deep_dives/wandb_logging.html), ce qui améliore le suivi et la visualisation des processus d’entraînement.
Consultez l’article de blog de W\&B sur le [Fine-tuning de Mistral 7B avec torchtune](https://wandb.ai/capecape/torchtune-mistral/reports/torchtune-The-new-PyTorch-LLM-fine-tuning-library---Vmlldzo3NTUwNjM0).
## La journalisation W\&B à portée de main
Redéfinissez les arguments de ligne de commande au lancement :
```bash theme={null}
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
```
Activez la journalisation W\&B dans la configuration de la recette :
```yaml theme={null}
# dans llama3/8B_lora_single_device.yaml
metric_logger:
_component_: torchtune.utils.metric_logging.WandBLogger
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()](/fr/models/ref/python/functions/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.
```yaml theme={null}
# 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
```
```shell theme={null}
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" \
metric_logger.entity="my_project" \
metric_logger.job_type="lora_finetune_single_device" \
metric_logger.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](https://wandb.ai/capecape/torchtune/runs/joyknwwa/files).
### 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 :
| Metric | Description |
| ------------------- | --------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| `loss` | La perte du modèle |
| `lr` | Le taux d’apprentissage |
| `tokens_per_second` | Le nombre de tokens par seconde du modèle |
| `grad_norm` | La norme du gradient du modèle |
| `global_step` | Correspond à 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](https://github.com/meta-pytorch/torchtune/tree/main/recipes) correspondant. Par exemple, vous pouvez enregistrer `current_epoch` comme pourcentage du nombre total d’époques, comme suit :
```python theme={null}
# 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](https://meta-pytorch.org/torchtune/stable/deep_dives/checkpointer.html). Selon l’origine du modèle que vous utilisez, vous devez utiliser la [classe de checkpointer](https://meta-pytorch.org/torchtune/stable/deep_dives/checkpointer.html) appropriée.
Si vous souhaitez enregistrer les points de contrôle du modèle dans les [W\&B Artifacts](/fr/models/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.
```python theme={null}
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)
```
Consultez l’article de blog de W\&B sur le [Fine-tuning de Mistral 7B avec torchtune](https://wandb.ai/capecape/torchtune-mistral/reports/torchtune-The-new-PyTorch-LLM-fine-tuning-library---Vmlldzo3NTUwNjM0).
