From a4f417b6e3f0540c7e8e60a1b548c8844c2ee08b Mon Sep 17 00:00:00 2001 From: "locadex-agent[bot]" <217277504+locadex-agent[bot]@users.noreply.github.com> Date: Thu, 9 Jul 2026 16:52:26 +0000 Subject: [PATCH 1/7] docs(locadex): add translations --- fr/models/integrations/accelerate.mdx | 36 +- .../integrations/add-wandb-to-any-library.mdx | 147 +- fr/models/integrations/autotrain.mdx | 24 +- .../integrations/azure-openai-fine-tuning.mdx | 58 +- fr/models/integrations/catalyst.mdx | 4 +- fr/models/integrations/cohere-fine-tuning.mdx | 28 +- fr/models/integrations/composer.mdx | 33 +- fr/models/integrations/dagster.mdx | 300 +- fr/models/integrations/databricks.mdx | 32 +- fr/models/integrations/deepchecks.mdx | 30 +- fr/models/integrations/deepchem.mdx | 27 +- fr/models/integrations/diffusers.mdx | 83 +- fr/models/integrations/docker.mdx | 18 +- fr/models/integrations/dspy.mdx | 42 +- fr/models/integrations/farama-gymnasium.mdx | 8 +- fr/models/integrations/fastai.mdx | 97 +- fr/models/integrations/fastai/v1.mdx | 43 +- fr/models/integrations/huggingface.mdx | 90 +- .../integrations/huggingface_transformers.mdx | 214 +- fr/models/integrations/hydra.mdx | 22 +- fr/models/integrations/ignite.mdx | 31 +- fr/models/integrations/keras.mdx | 65 +- .../integrations/kubeflow-pipelines-kfp.mdx | 52 +- fr/models/integrations/lightgbm.mdx | 12 +- fr/models/integrations/lightning.mdx | 129 +- fr/models/integrations/metaflow.mdx | 72 +- fr/models/integrations/mmengine.mdx | 36 +- fr/models/integrations/mmf.mdx | 28 +- fr/models/integrations/nim.mdx | 56 +- fr/models/integrations/openai-api.mdx | 46 +- fr/models/integrations/openai-fine-tuning.mdx | 116 +- fr/models/integrations/openai-gym.mdx | 10 +- fr/models/integrations/paddledetection.mdx | 38 +- fr/models/integrations/paddleocr.mdx | 36 +- fr/models/integrations/prodigy.mdx | 18 +- fr/models/integrations/pytorch-geometric.mdx | 34 +- fr/models/integrations/pytorch.mdx | 203 +- fr/models/integrations/ray-tune.mdx | 42 +- fr/models/integrations/sagemaker.mdx | 14 +- fr/models/integrations/scikit.mdx | 66 +- fr/models/integrations/simpletransformers.mdx | 27 +- fr/models/integrations/skorch.mdx | 46 +- fr/models/integrations/spacy.mdx | 34 +- fr/models/integrations/stable-baselines-3.mdx | 29 +- fr/models/integrations/tensorboard.mdx | 26 +- fr/models/integrations/tensorflow.mdx | 57 +- fr/models/integrations/torchtune.mdx | 62 +- fr/models/integrations/ultralytics.mdx | 94 +- fr/models/integrations/w-and-b-for-julia.mdx | 16 +- fr/models/integrations/xgboost.mdx | 49 +- fr/models/integrations/yolov5.mdx | 30 +- fr/models/integrations/yolox.mdx | 36 +- gt-lock.json | 7640 ++++++++--------- ja/models/integrations/accelerate.mdx | 32 +- .../integrations/add-wandb-to-any-library.mdx | 139 +- ja/models/integrations/autotrain.mdx | 26 +- .../integrations/azure-openai-fine-tuning.mdx | 56 +- ja/models/integrations/catalyst.mdx | 4 +- ja/models/integrations/cohere-fine-tuning.mdx | 22 +- ja/models/integrations/composer.mdx | 33 +- ja/models/integrations/dagster.mdx | 256 +- ja/models/integrations/databricks.mdx | 34 +- ja/models/integrations/deepchecks.mdx | 18 +- ja/models/integrations/deepchem.mdx | 25 +- ja/models/integrations/diffusers.mdx | 101 +- ja/models/integrations/docker.mdx | 18 +- ja/models/integrations/dspy.mdx | 44 +- ja/models/integrations/farama-gymnasium.mdx | 8 +- ja/models/integrations/fastai.mdx | 93 +- ja/models/integrations/fastai/v1.mdx | 39 +- ja/models/integrations/huggingface.mdx | 82 +- .../integrations/huggingface_transformers.mdx | 200 +- ja/models/integrations/hydra.mdx | 22 +- ja/models/integrations/ignite.mdx | 41 +- ja/models/integrations/keras.mdx | 89 +- .../integrations/kubeflow-pipelines-kfp.mdx | 48 +- ja/models/integrations/lightgbm.mdx | 16 +- ja/models/integrations/lightning.mdx | 107 +- ja/models/integrations/metaflow.mdx | 56 +- ja/models/integrations/mmengine.mdx | 26 +- ja/models/integrations/mmf.mdx | 30 +- ja/models/integrations/nim.mdx | 56 +- ja/models/integrations/openai-api.mdx | 46 +- ja/models/integrations/openai-fine-tuning.mdx | 118 +- ja/models/integrations/openai-gym.mdx | 6 +- ja/models/integrations/paddledetection.mdx | 36 +- ja/models/integrations/paddleocr.mdx | 36 +- ja/models/integrations/prodigy.mdx | 14 +- ja/models/integrations/pytorch-geometric.mdx | 34 +- ja/models/integrations/pytorch.mdx | 186 +- ja/models/integrations/ray-tune.mdx | 42 +- ja/models/integrations/sagemaker.mdx | 12 +- ja/models/integrations/scikit.mdx | 60 +- ja/models/integrations/simpletransformers.mdx | 29 +- ja/models/integrations/skorch.mdx | 42 +- ja/models/integrations/spacy.mdx | 34 +- ja/models/integrations/stable-baselines-3.mdx | 25 +- ja/models/integrations/tensorboard.mdx | 22 +- ja/models/integrations/tensorflow.mdx | 53 +- ja/models/integrations/torchtune.mdx | 62 +- ja/models/integrations/ultralytics.mdx | 102 +- ja/models/integrations/w-and-b-for-julia.mdx | 10 +- ja/models/integrations/xgboost.mdx | 41 +- ja/models/integrations/yolov5.mdx | 26 +- ja/models/integrations/yolox.mdx | 34 +- ko/models/integrations/accelerate.mdx | 28 +- .../integrations/add-wandb-to-any-library.mdx | 137 +- ko/models/integrations/autotrain.mdx | 22 +- .../integrations/azure-openai-fine-tuning.mdx | 50 +- ko/models/integrations/catalyst.mdx | 4 +- ko/models/integrations/cohere-fine-tuning.mdx | 20 +- ko/models/integrations/composer.mdx | 31 +- ko/models/integrations/dagster.mdx | 308 +- ko/models/integrations/databricks.mdx | 36 +- ko/models/integrations/deepchecks.mdx | 30 +- ko/models/integrations/deepchem.mdx | 27 +- ko/models/integrations/diffusers.mdx | 73 +- ko/models/integrations/docker.mdx | 18 +- ko/models/integrations/dspy.mdx | 46 +- ko/models/integrations/farama-gymnasium.mdx | 8 +- ko/models/integrations/fastai.mdx | 95 +- ko/models/integrations/fastai/v1.mdx | 42 +- ko/models/integrations/huggingface.mdx | 82 +- .../integrations/huggingface_transformers.mdx | 200 +- ko/models/integrations/hydra.mdx | 26 +- ko/models/integrations/ignite.mdx | 43 +- ko/models/integrations/keras.mdx | 86 +- .../integrations/kubeflow-pipelines-kfp.mdx | 50 +- ko/models/integrations/lightgbm.mdx | 16 +- ko/models/integrations/lightning.mdx | 74 +- ko/models/integrations/metaflow.mdx | 44 +- ko/models/integrations/mmengine.mdx | 26 +- ko/models/integrations/mmf.mdx | 24 +- ko/models/integrations/nim.mdx | 58 +- ko/models/integrations/openai-api.mdx | 46 +- ko/models/integrations/openai-fine-tuning.mdx | 110 +- ko/models/integrations/openai-gym.mdx | 4 +- ko/models/integrations/paddledetection.mdx | 34 +- ko/models/integrations/paddleocr.mdx | 34 +- ko/models/integrations/prodigy.mdx | 10 +- ko/models/integrations/pytorch-geometric.mdx | 30 +- ko/models/integrations/pytorch.mdx | 185 +- ko/models/integrations/ray-tune.mdx | 44 +- ko/models/integrations/sagemaker.mdx | 12 +- ko/models/integrations/scikit.mdx | 68 +- ko/models/integrations/simpletransformers.mdx | 29 +- ko/models/integrations/skorch.mdx | 30 +- ko/models/integrations/spacy.mdx | 34 +- ko/models/integrations/stable-baselines-3.mdx | 33 +- ko/models/integrations/tensorboard.mdx | 24 +- ko/models/integrations/tensorflow.mdx | 53 +- ko/models/integrations/torchtune.mdx | 66 +- ko/models/integrations/ultralytics.mdx | 104 +- ko/models/integrations/w-and-b-for-julia.mdx | 14 +- ko/models/integrations/xgboost.mdx | 43 +- ko/models/integrations/yolov5.mdx | 28 +- ko/models/integrations/yolox.mdx | 34 +- 157 files changed, 8359 insertions(+), 7791 deletions(-) diff --git a/fr/models/integrations/accelerate.mdx b/fr/models/integrations/accelerate.mdx index c9c67bd40f..78c7eff189 100644 --- a/fr/models/integrations/accelerate.mdx +++ b/fr/models/integrations/accelerate.mdx @@ -5,13 +5,13 @@ title: Hugging Face Accelerate Hugging Face Accelerate est une bibliothèque qui permet d'exécuter le même code PyTorch sur n'importe quelle configuration distribuée, afin de simplifier l'entraînement des modèles et l'inférence à grande échelle. -Accelerate inclut un suivi W&B, que nous expliquons comment utiliser ci-dessous. Vous pouvez aussi en savoir plus sur les [suivis Accelerate dans Hugging Face](https://huggingface.co/docs/accelerate/main/en/usage_guides/tracking). +Accelerate inclut un suivi W&B, et cette page montre comment l'utiliser pour consigner des métriques, la configuration et des artefacts à partir de runs d'entraînement distribués dans W&B. Pour plus d'informations, voir [Accelerate Trackers in Hugging Face](https://huggingface.co/docs/accelerate/main/en/usage_guides/tracking).
## Commencez à journaliser avec Accelerate
-Pour démarrer avec Accelerate et W&B, vous pouvez suivre le pseudocode ci-dessous : +Cette section montre comment configurer Accelerate pour journaliser les données d'expérience dans W&B pendant l'entraînement. Pour démarrer avec Accelerate et W&B, suivez ce pseudocode : ```python from accelerate import Accelerator @@ -36,39 +36,37 @@ accelerator.log({"train_loss": 1.12, "valid_loss": 0.8}, step=global_step) accelerator.end_training() ``` -Plus précisément, vous devez : +Plus en détail : -1. Passer `log_with="wandb"` lors de l'initialisation de la classe Accelerator -2. Appeler la méthode [`init_trackers`](https://huggingface.co/docs/accelerate/main/en/package_reference/accelerator#accelerate.Accelerator.init_trackers) et lui transmettre : - -* un nom de projet via `project_name` -* tous les paramètres que vous souhaitez passer à [`wandb.init()`](/fr/models/ref/python/functions/init) via un `dict` imbriqué dans `init_kwargs` -* toute autre information de configuration de l'expérience que vous souhaitez journaliser dans votre run wandb, via `config` - -3. Utiliser la méthode `wandb.Run.log()` pour journaliser dans Weights & Biases ; l'argument `step` est facultatif -4. Appeler `.end_training()` une fois l'entraînement terminé +1. Passez `log_with="wandb"` lorsque vous initialisez la classe `Accelerator`. +2. Appelez la méthode [`init_trackers`](https://huggingface.co/docs/accelerate/main/en/package_reference/accelerator#accelerate.Accelerator.init_trackers) et transmettez-lui : + * Un nom de projet via `project_name`. + * Tous les paramètres que vous souhaitez passer à [`wandb.init()`](/fr/models/ref/python/functions/init) via un `dict` imbriqué dans `init_kwargs`. + * Toute autre information de configuration de l'expérience que vous souhaitez journaliser dans votre run wandb, via `config`. +3. Utilisez la méthode `wandb.Run.log()` pour journaliser dans W&B. L'argument `step` est facultatif. +4. Appelez `.end_training()` lorsque l'entraînement est terminé.
- ## Accéder à l’outil de suivi W&B + ## Accéder au suivi W&B
-Pour accéder à l’outil de suivi W&B, utilisez la méthode `Accelerator.get_tracker()`. Passez la chaîne correspondant à l’attribut `.name` d’un outil de suivi ; la méthode renvoie alors cet outil de suivi sur le processus `main`. +Une fois qu’Accelerate journalise dans W&B, vous pouvez avoir besoin d’accéder directement à l’objet run W&B sous-jacent pour journaliser des artefacts, des graphiques personnalisés ou d’autres données que le suivi W&B n’expose pas. Pour accéder au suivi W&B, utilisez la méthode `Accelerator.get_tracker()`. Passez la chaîne correspondant à l’attribut `.name` d’un outil de suivi ; la méthode renvoie alors cet outil de suivi sur le processus `main`. ```python wandb_tracker = accelerator.get_tracker("wandb") ``` -Vous pouvez ensuite interagir normalement avec l’objet run de wandb : +Vous pouvez ensuite interagir comme d’habitude avec l’objet run de `wandb` : ```python wandb_tracker.log_artifact(some_artifact_to_log) ``` - Les suivis intégrés à Accelerate s’exécutent automatiquement sur le bon processus. Ainsi, si un suivi ne doit être exécuté que sur le processus principal, il le sera automatiquement. + Les suivis intégrés à Accelerate s’exécutent automatiquement sur le bon processus. Ainsi, si un suivi n’a besoin d’être exécuté que sur le processus principal, il le sera automatiquement. - Si vous souhaitez vraiment supprimer complètement l’encapsulation d’Accelerate, vous pouvez obtenir le même résultat avec : + Pour supprimer complètement l’encapsulation d’Accelerate, vous pouvez obtenir le même résultat avec : ```python wandb_tracker = accelerator.get_tracker("wandb", unwrap=True) @@ -81,12 +79,12 @@ wandb_tracker.log_artifact(some_artifact_to_log) ## Articles sur Accelerate -Vous trouverez ci-dessous un article sur Accelerate susceptible de vous intéresser +Pour un guide pas à pas plus approfondi sur l’utilisation d’Accelerate avec W&B, consultez l’article suivant.
HuggingFace Accelerate optimisé avec W&B - * Dans cet article, nous examinons ce que HuggingFace Accelerate a à offrir et à quel point il est simple d'effectuer un entraînement et une évaluation distribués, tout en enregistrant les résultats dans W&B. + Cet article examine ce que HuggingFace Accelerate a à offrir et explique comment effectuer un entraînement et une évaluation distribués, tout en enregistrant les résultats dans W&B. Lire le [rapport Hugging Face Accelerate optimisé avec W&B](https://wandb.ai/gladiator/HF%20Accelerate%20+%20W\&B/reports/Hugging-Face-Accelerate-Super-Charged-with-Weights-Biases--VmlldzoyNzk3MDUx?utm_source=docs\&utm_medium=docs\&utm_campaign=accelerate-docs).
diff --git a/fr/models/integrations/add-wandb-to-any-library.mdx b/fr/models/integrations/add-wandb-to-any-library.mdx index 10464c010a..18cd8aee1b 100644 --- a/fr/models/integrations/add-wandb-to-any-library.mdx +++ b/fr/models/integrations/add-wandb-to-any-library.mdx @@ -1,31 +1,31 @@ --- title: Ajouter W&B à une bibliothèque Python -description: Bonnes pratiques pour intégrer Weights & Biases dans votre bibliothèque Python afin d’assurer le suivi des expériences, la surveillance du système et la gestion des modèles. +description: Bonnes pratiques pour intégrer W&B à votre bibliothèque Python pour le suivi des expériences, la surveillance système et Model Management. --- import ApiKeyCreateStreamlined from "/snippets/fr/_includes/api-key-create-streamlined.mdx"; -Ce guide explique comment intégrer Weights & Biases (W&B) à une bibliothèque Python. +Ce guide explique comment intégrer W&B à une bibliothèque Python afin que vos utilisateurs puissent suivre les expériences, surveiller les métriques système et gérer des modèles lorsqu’ils utilisent votre code. Il s’adresse aux auteurs et mainteneurs de bibliothèques qui souhaitent exposer les fonctionnalités de W&B via leur propre framework, SDK ou code d’entraînement réutilisable. -Suivez ces recommandations si vous intégrez W&B à une base de code complexe, comme un framework d'entraînement, un SDK ou une bibliothèque réutilisable. +Suivez ces recommandations si vous intégrez W&B dans une base de code complexe (comme un framework d’entraînement, un SDK ou une bibliothèque réutilisable), c’est-à-dire lorsque cette base de code va au-delà d’un simple script d’entraînement Python ou d’un notebook Jupyter. - Si vous débutez avec W&B, consultez les guides essentiels (par exemple, [Suivi des expériences](/fr/models/track/)) avant de continuer. + Si vous débutez avec W&B, consultez les guides de base (par exemple, [Suivi des expériences](/fr/models/track/)) avant de poursuivre. -Vous trouverez ci-dessous des conseils et bonnes pratiques pour les cas où la base de code sur laquelle vous travaillez est plus complexe qu'un simple script d'entraînement Python ou qu'un notebook Jupyter. +Les sections suivantes présentent, dans l’ordre, les principales décisions d’intégration : comment installer W&B, comment vous authentifier, comment démarrer et configurer des exécutions, comment consigner des métriques et des artefacts, et comment prendre en charge l’entraînement distribué et les Sweeps d’hyperparamètres.
## Déterminez comment les utilisateurs installent W&B
-Avant de commencer, déterminez si W&B doit être une dépendance obligatoire ou une fonctionnalité facultative de votre bibliothèque. +Avant de commencer, déterminez si W&B doit être une dépendance obligatoire ou une fonctionnalité facultative de votre bibliothèque. Ce choix a une incidence sur la façon dont vous importez le SDK Python W&B (`wandb`), documentez l'installation et gérez les environnements dans lesquels `wandb` n'est pas présent.
### Exiger W&B comme dépendance
-Si W&B est au cœur des fonctionnalités de votre bibliothèque, ajoutez le SDK Python de W&B (`wandb`) à vos dépendances : +Si W&B est au cœur des fonctionnalités de votre bibliothèque, ajoutez `wandb` à vos dépendances afin qu'il soit installé automatiquement avec votre bibliothèque : ```txt torch==1.8.0 @@ -37,7 +37,7 @@ wandb==0.13.* ### Rendre W&B facultatif à l’installation -Si W&B est une fonctionnalité facultative, permettez à votre bibliothèque de fonctionner sans que W&B soit installé. +Si W&B est une fonctionnalité facultative, permettez à votre bibliothèque de fonctionner sans que W&B soit installé, afin que les utilisateurs qui n’ont pas besoin du suivi des expériences puissent quand même utiliser votre code. Vous pouvez soit importer `wandb` conditionnellement en Python, soit le déclarer comme dépendance facultative dans `pyproject.toml`. @@ -78,13 +78,13 @@ Vous pouvez soit importer `wandb` conditionnellement en Python, soit le déclare ## Authentifiez les utilisateurs -W&B utilise des clés API pour authentifier les utilisateurs et les machines. +W&B utilise des clés API pour authentifier les utilisateurs et les machines. Avant que les utilisateurs puissent enregistrer des runs depuis votre bibliothèque, ils doivent générer une clé API et la rendre disponible pour le client `wandb`.
### Créer une clé API
-Une clé API permet d’authentifier un client ou une machine auprès de W&B. Vous pouvez générer une clé API depuis votre profil utilisateur. +Une clé API permet d’authentifier un client ou une machine auprès de W&B. Générez une clé API depuis votre profil utilisateur afin de pouvoir l’utiliser pour les étapes de connexion qui suivent. @@ -95,11 +95,11 @@ Une clé API permet d’authentifier un client ou une machine auprès de W&B ### Installez W&B et connectez-vous -Pour installer la bibliothèque `wandb` localement et vous connecter : +Une fois que vous avez une clé API, installez la bibliothèque `wandb` localement et connectez-vous afin que les runs suivants puissent s’authentifier auprès de W&B. Choisissez l’onglet correspondant à votre environnement. - 1. Définissez la [variable d'environnement](/fr/models/track/environment-variables/) `WANDB_API_KEY` avec votre clé API : + 1. Définissez la [variable d'environnement](/fr/models/track/environment-variables/) `WANDB_API_KEY` avec votre clé API. Remplacez les valeurs entre `<>` par les vôtres : ```bash export WANDB_API_KEY= @@ -120,7 +120,7 @@ Pour installer la bibliothèque `wandb` localement et vous connecter : pip install wandb ``` - 2. Connectez-vous à W&B depuis votre script ou notebook Python. Vous serez invité à saisir + 2. Connectez-vous à W&B depuis votre script ou notebook Python. W&B vous invitera à saisir votre clé API. ```python import wandb @@ -129,9 +129,9 @@ Pour installer la bibliothèque `wandb` localement et vous connecter : - Copiez-collez l'extrait de code suivant dans une cellule de votre notebook Jupyter, puis exécutez-le. Vous serez invité à saisir votre clé API. + Copiez-collez l'extrait de code suivant dans une cellule de votre notebook Jupyter, puis exécutez-le. W&B vous invitera à saisir votre clé API. - ```notebook + ```python !pip install wandb import wandb @@ -144,16 +144,18 @@ Pour installer la bibliothèque `wandb` localement et vous connecter : ## Lancer un run +Après avoir configuré l’authentification, l’étape suivante consiste à lancer un run W&B afin que votre bibliothèque ait un emplacement où consigner des métriques, des configurations et des artéfacts. + Un *run* représente une seule unité de calcul, comme une expérience d’entraînement. La plupart des bibliothèques créent un run par tâche d'entraînement. Pour en savoir plus sur les runs, voir [W&B Runs](/fr/models/runs/). -Initialisez un run avec [`wandb.init()`](/fr/models/ref/python/functions/init) et indiquez le nom de votre projet et de votre entité d’équipe (nom de l’équipe). Si vous ne spécifiez pas de projet, W&B stocke votre run dans un projet par défaut appelé "uncategorized".: +Initialisez un run avec [`wandb.init()`](/fr/models/ref/python/functions/init) et indiquez le nom de votre projet et de votre entité d’équipe (nom de l’équipe). Si vous ne spécifiez pas de projet, W&B stocke votre run dans un projet par défaut appelé "uncategorized". Remplacez les valeurs entre `<>` par les vôtres : ```python with wandb.init(project="", entity="") as run: ... ``` -W&B recommande d’utiliser un gestionnaire de contexte pour s’assurer que votre run est correctement fermé, même en cas d’erreur. Si vous n’utilisez pas de gestionnaire de contexte, vous devez appeler `run.finish()` pour fermer le run et journaliser toutes les données dans W&B. +W&B recommande d’utiliser un gestionnaire de contexte pour s’assurer que votre run est correctement fermé, même en cas d’erreur. Si vous n’utilisez pas de gestionnaire de contexte, vous devez appeler `run.finish()` pour fermer le run et journaliser toutes les données dans W&B. La fermeture du run garantit que toutes les métriques, configurations et artefacts sont téléversés avant que le processus ne se termine. **Quand appeler `wandb.init()`** @@ -167,16 +169,29 @@ W&B recommande d’utiliser un gestionnaire de contexte pour s’assurer que ### Définir `wandb` comme dépendance facultative -Si vous souhaitez rendre `wandb` facultatif pour les utilisateurs de votre bibliothèque, vous pouvez soit : +Si vous souhaitez rendre `wandb` facultatif à l'exécution, afin que les utilisateurs puissent exécuter votre bibliothèque sans produire de runs W&B, utilisez l'une des approches suivantes : -* Définir une option `wandb`, par exemple : +* Définir une option `wandb`. +* Définir `wandb` sur `disabled` dans `wandb.init()`. +* Définir `wandb` en mode hors ligne. `wandb` s'exécute toujours, mais ne communique pas avec W&B via Internet. + +Définissez une option `wandb`, par exemple : - `python trainer = my_trainer(..., use_wandb=True) ` - `bash python train.py ... --use-wandb ` + + ```python + trainer = my_trainer(..., use_wandb=True) + ``` + + + + ```bash + python train.py ... --use-wandb + ``` + -* Ou définir `wandb` sur `disabled` dans `wandb.init()` : +Définissez `wandb` sur `disabled` dans `wandb.init()` : @@ -198,7 +213,7 @@ Si vous souhaitez rendre `wandb` facultatif pour les utilisateurs de votre bibli -* Ou définir `wandb` en mode hors ligne - notez que `wandb` s'exécutera quand même, mais n'essaiera simplement pas de communiquer avec W&B via Internet : +Définissez `wandb` en mode hors ligne : @@ -224,11 +239,13 @@ Si vous souhaitez rendre `wandb` facultatif pour les utilisateurs de votre bibli ## Définir une configuration de run +Après avoir initialisé un run, vous pouvez y joindre un dictionnaire de configuration qui enregistre les hyperparamètres et les autres métadonnées associés à ce run. La journalisation d’une configuration facilite la comparaison, le filtrage et la reproduction ultérieure des runs. + Fournissez un dictionnaire de configuration lorsque vous initialisez votre run afin d’enregistrer les hyperparamètres et d’autres métadonnées dans W&B. -Utilisez l’application W&B pour comparer les runs en fonction de leurs paramètres de configuration et les filtrer dans le tableau Runs. Vous pouvez également utiliser ces paramètres pour regrouper des runs dans l’application W&B. +Utilisez W&B pour comparer les runs en fonction de leurs paramètres de configuration et les filtrer dans le tableau Runs. Vous pouvez également utiliser ces paramètres pour regrouper des runs dans W&B. -Par exemple, dans l’image suivante, la taille de lot (bathch_size) a été définie comme paramètre de configuration et est visible (voir la première colonne) dans le tableau Runs. Cela permet aux utilisateurs de filtrer et de comparer les runs en fonction de leur taille de lot : +Par exemple, dans l’image suivante, la taille de lot (`batch_size`) est définie comme paramètre de configuration et est visible (voir la première colonne) dans le tableau Runs. Cela permet aux utilisateurs de filtrer et de comparer les runs en fonction de leur taille de lot : tableau Runs de W&B @@ -252,7 +269,7 @@ with wandb.init(..., config=config) as run: ### Mettre à jour la configuration de run -Si certaines valeurs ne sont pas disponibles au moment de l’initialisation, mettez à jour la configuration plus tard avec `wandb.Run.config.update`. Par exemple, il se peut que vous souhaitiez ajouter les paramètres d’un modèle après son instanciation : +Certaines valeurs de configuration, comme le nombre de paramètres du modèle, peuvent ne pas être connues lorsque vous appelez `wandb.init()`. Si certaines valeurs ne sont pas disponibles au moment de l’initialisation, mettez à jour la configuration plus tard avec `wandb.Run.config.update`. Par exemple, il se peut que vous souhaitiez ajouter les paramètres d’un modèle après son instanciation : ```python with wandb.init(...) as run: @@ -260,17 +277,19 @@ with wandb.init(...) as run: run.config.update({"model_parameters": 3500}) ``` -Pour plus de détails, voir [Configurer Experiments](/fr/models/track/config/). +Pour plus d'informations, voir [Configurer les expériences](/fr/models/track/config/).
- ## Journaliser les métriques et les données + ## Consigner des métriques et des données
+Une fois le run démarré et configuré, vous pouvez commencer à consigner des métriques et d’autres données afin que W&B les enregistre pour ce run. +
### Journaliser des métriques
-Créez un dictionnaire dans lequel la clé correspond au nom de la métrique. Passez ce dictionnaire à [`wandb.Run.log()`](/fr/models/ref/python/experiments/run#method-run-log) pour le journaliser dans W&B : +Pour journaliser des métriques scalaires telles que la perte ou la précision, créez un dictionnaire dans lequel chaque clé correspond au nom d’une métrique. Passez ce dictionnaire à [`wandb.Run.log()`](/fr/models/ref/python/experiments/run#method-run-log) pour le journaliser dans W&B : ```python NUM_EPOCHS = 10 @@ -283,9 +302,9 @@ for epoch in range(NUM_EPOCHS): run.log(metrics) ``` -Utilisez des préfixes de noms de métriques pour regrouper les métriques associées dans l’application W&B. Les préfixes courants incluent `train/` et `val/` pour les métriques d'entraînement et de validation, respectivement, mais vous pouvez utiliser n'importe quel préfixe adapté à votre cas d'usage. +Utilisez des préfixes de noms de métriques pour regrouper les métriques associées dans W&B. Les préfixes courants incluent `train/` et `val/` pour les métriques d'entraînement et de validation, respectivement, mais vous pouvez utiliser n'importe quel préfixe adapté à votre cas d'usage. -Cela créera des sections distinctes dans l’espace de travail de votre projet pour vos métriques d'entraînement et de validation, ou pour d'autres types de métriques que vous souhaitez séparer : +Cela crée des sections distinctes dans l’espace de travail de votre projet pour vos métriques d'entraînement et de validation, ou pour d'autres types de métriques que vous souhaitez séparer : ```python with wandb.init(...) as run: @@ -302,13 +321,13 @@ with wandb.init(...) as run: W&B Workspace -Voir [`wandb.Run.log()`](/fr/models/ref/python/experiments/run#method-run-log) pour en savoir plus. +Pour plus d'informations, voir [`wandb.Run.log()`](/fr/models/ref/python/experiments/run#method-run-log).
### Contrôler l’axe x
-Si vous effectuez plusieurs appels à `wandb.Run.log()` pour la même étape d’entraînement, le SDK wandb incrémente un compteur interne à chaque appel à `wandb.Run.log()`. Ce compteur peut ne pas correspondre à l’étape d’entraînement de votre boucle d’entraînement. +Par défaut, le SDK Python de W&B gère son propre compteur d’étapes, qui peut ne pas correspondre à la logique des étapes de votre boucle d’entraînement. Si vous effectuez plusieurs appels à `wandb.Run.log()` pour la même étape d’entraînement, le SDK wandb incrémente un compteur interne à chaque appel à `wandb.Run.log()`. Ce compteur peut ne pas correspondre à l’étape d’entraînement de votre boucle d’entraînement. Pour éviter cette situation, définissez explicitement l’étape de l’axe x avec `wandb.Run.define_metric()`, une seule fois, immédiatement après avoir appelé `wandb.init()` : @@ -317,7 +336,7 @@ with wandb.init(...) as run: run.define_metric("*", step_metric="global_step") ``` -Le motif glob `*` signifie que chaque métrique utilisera `global_step` sur l’axe des x de vos graphiques. Si vous souhaitez que seules certaines métriques soient journalisées en fonction de `global_step`, vous pouvez les spécifier à la place : +Le motif glob `*` signifie que chaque métrique utilise `global_step` sur l’axe des x de vos graphiques. Si vous souhaitez que seules certaines métriques soient journalisées en fonction de `global_step`, vous pouvez les spécifier à la place : ```python run.define_metric("train/loss", step_metric="global_step") @@ -332,77 +351,79 @@ for step, (input, ground_truth) in enumerate(data): run.log({"global_step": step, "eval/loss": 0.2}) ``` -Si vous n’avez pas accès à la variable d’étape indépendante, par exemple si "global_step" n’est pas disponible pendant votre boucle de validation, la valeur précédemment journalisée pour "global_step" est automatiquement utilisée par wandb. Dans ce cas, assurez-vous de journaliser une valeur initiale pour la métrique afin qu’elle soit définie au moment voulu. +Si vous n’avez pas accès à la variable d’étape indépendante (par exemple, `global_step` n’est pas disponible pendant votre boucle de validation), la valeur précédemment journalisée pour `global_step` est automatiquement utilisée par W&B. Dans ce cas, assurez-vous de journaliser une valeur initiale pour la métrique afin qu’elle soit définie au moment voulu.
### Journaliser des médias et des données structurées
-Outre les scalaires, vous pouvez consigner des images, des tableaux, du texte, de l’audio, de la vidéo, etc. +Outre les scalaires, vous pouvez consigner des images, des tableaux, du texte, de l’audio, de la vidéo, etc. La journalisation des médias avec les métriques aide les utilisateurs à examiner le comportement qualitatif du modèle au fil du temps. Voici quelques points à prendre en compte lorsque vous enregistrez des données : * À quelle fréquence la métrique doit-elle être enregistrée ? Doit-elle être facultative ? * Quel type de données peut être utile pour la visualisation ? - * Pour les images, vous pouvez enregistrer des exemples de prédictions, des masques de segmentation, etc., afin d’observer leur évolution au fil du temps. + * Pour les images, vous pouvez enregistrer des exemples de prédictions et des masques de segmentation afin d’observer leur évolution au fil du temps. * Pour le texte, vous pouvez enregistrer des tableaux d’exemples de prédictions pour les explorer plus tard. -Voir [Journaliser des objets et des médias](/fr/models/track/log) pour des exemples. +Pour plus d'informations, voir [Journaliser des objets et des médias](/fr/models/track/log).
## Prise en charge de l’entraînement distribué
-Pour les frameworks compatibles avec les environnements distribués, vous pouvez adapter l’un des flux de travail suivants : +Si votre bibliothèque peut exécuter l’entraînement sur plusieurs processus ou machines, décidez comment W&B doit se comporter dans ce contexte afin que les journaux soient cohérents et non dupliqués. Pour les frameworks compatibles avec les environnements distribués, vous pouvez adapter l’un des flux de travail suivants : * Journalisez uniquement depuis le processus principal (recommandé). * Journalisez depuis chaque processus et regroupez les runs à l’aide d’un nom `group` partagé. -Voir [Journaliser des Experiments d’entraînement distribué](/fr/models/track/log/distributed-training/) pour plus de détails. +Pour plus d'informations, voir [Journaliser des expériences d’entraînement distribué](/fr/models/track/log/distributed-training/).
- ## Suivre les modèles et les Datasets avec Artifacts + ## Suivre les modèles et les Datasets avec des artefacts
-Utilisez [W&B Artifacts](/fr/models/artifacts/) pour suivre les modèles et les Datasets et en assurer la gestion des versions. Artifacts fournissent le stockage et la gestion des versions des ressources de machine learning, et assurent automatiquement la traçabilité afin de montrer comment les données et les modèles sont liés. +En plus des métriques, vous pouvez conserver les modèles et les Datasets que votre bibliothèque produit ou consomme afin que les utilisateurs puissent reproduire et comparer les runs. + +Utilisez [W&B Artefacts](/fr/models/artifacts/) pour suivre les modèles et les Datasets et en assurer la gestion des versions. Les artefacts fournissent le stockage et la gestion des versions des ressources de machine learning, et assurent automatiquement la traçabilité afin de montrer comment les données et les modèles sont liés. Datasets stockés et points de contrôle du modèle dans W&B -Tenez compte des points suivants lorsque vous intégrez Artifacts à votre bibliothèque : +Tenez compte des points suivants lorsque vous intégrez les artefacts à votre bibliothèque : -* Déterminez s'il faut journaliser les points de contrôle du modèle ou les Datasets en tant qu'Artifacts (si vous souhaitez rendre cela facultatif). -* Références d'entrée d'Artifacts (par exemple, `entity/project/artifact`). -* Fréquence de journalisation des points de contrôle du modèle ou des Datasets. Par exemple, à chaque époque, toutes les 500 étapes, etc. +* Déterminez s'il faut journaliser les points de contrôle du modèle ou les Datasets en tant qu'artefacts (si vous souhaitez rendre cela facultatif). +* Références d'entrée d'artefacts (par exemple, `entity/project/artifact`). +* Fréquence de journalisation des points de contrôle du modèle ou des Datasets. Par exemple, à chaque époque ou toutes les 500 étapes.
### Journaliser les points de contrôle du modèle
-Journalisez les points de contrôle du modèle dans W&B. Une approche courante consiste à journaliser les points de contrôle comme des artifacts, en utilisant le run ID unique généré par W&B dans le nom de l'artifact. +La journalisation des points de contrôle du modèle en tant qu’artefacts permet aux utilisateurs de récupérer, de versionner et de partager les poids entraînés. Une approche courante consiste à journaliser les points de contrôle comme des artefacts, en utilisant le run ID unique généré par W&B dans le nom de l'artefact. ```python -metadata = {"eval/accuracy": 0.8, "train/steps": 800} +metadata = {"eval/accuracy": 0.8, "train/steps": 800} artifact = wandb.Artifact( - name=f"model-{run.id}", - metadata=metadata, + name=f"model-{run.id}", + metadata=metadata, type="model" - ) + ) artifact.add_dir("output_model") # répertoire local où les poids du modèle sont stockés -aliases = ["best", "epoch_10"] +aliases = ["best", "epoch_10"] run.log_artifact(artifact, aliases=aliases) ``` -L’extrait de code précédent montre comment journaliser un point de contrôle du modèle en tant qu’artifact et ajouter des métadonnées telles que la précision de l’évaluation et les étapes d’entraînement. L’artifact se voit attribuer un nom qui inclut le run ID unique, et il est étiqueté avec des [alias personnalisés](/fr/models/artifacts/create-a-custom-alias/) pour s’y référer facilement. +L’extrait précédent journalise un point de contrôle du modèle en tant qu’artefact avec des métadonnées telles que la précision de l’évaluation et les étapes d’entraînement. Le nom de l’artefact inclut le run ID unique, et il est étiqueté avec des [alias personnalisés](/fr/models/artifacts/create-a-custom-alias/) pour s’y référer rapidement.
- ### Journaliser les artifacts en entrée + ### Journaliser les artefacts en entrée
-Journalisez les Datasets ou les modèles préentraînés utilisés en entrée : +Pour capturer la traçabilité entre les données et les modèles, journalisez les datasets ou les modèles préentraînés qu’un run utilise en entrée : ```python dataset = wandb.Artifact(name="flowers", type="dataset") @@ -410,15 +431,15 @@ dataset.add_file("flowers.npy") run.use_artifact(dataset) ``` -L’extrait de code précédent crée un artifact pour un jeu de données nommé "flowers" et y ajoute un fichier. L’artifact est ensuite associé au run en cours à l’aide de `run.use_artifact()`, ce qui permet à W&B de suivre la traçabilité du jeu de données utilisé dans le run. +L’extrait de code précédent crée un artefact pour un dataset nommé "flowers" et y ajoute un fichier. L’appel à `wandb.Run.use_artifact()` associe l’artefact au run en cours afin que W&B puisse suivre la traçabilité du dataset utilisé dans le run.
- ### Télécharger des Artifacts + ### Télécharger des artefacts
-Téléchargez des Artifacts déjà enregistrés dans W&B afin de les utiliser dans votre code d’entraînement ou d’inférence. +Après avoir enregistré des artefacts, vous pouvez télécharger des artefacts précédemment enregistrés depuis W&B afin de les utiliser dans votre code d’entraînement ou d’inférence. La bonne approche dépend du fait que vous disposiez déjà ou non d’un run actif. -Si vous disposez d’un contexte de run, utilisez [`wandb.Run.use_artifact()`](/fr/models/ref/python/experiments/run) pour faire référence à un artifact dans W&B, puis appelez [`wandb.Artifact.download()`](/fr/models/ref/python/experiments/artifact) pour le télécharger dans un répertoire local. +Si vous disposez d’un contexte de run, utilisez [`wandb.Run.use_artifact()`](/fr/models/ref/python/experiments/run) pour faire référence à un artefact dans W&B, puis appelez [`wandb.Artifact.download()`](/fr/models/ref/python/experiments/artifact) pour le télécharger dans un répertoire local. L’utilisation de `wandb.Run.use_artifact()` enregistre également l’artefact comme entrée du run actuel, ce qui préserve la traçabilité. ```python with wandb.init(...) as run: @@ -426,7 +447,7 @@ with wandb.init(...) as run: local_path = artifact.download() ``` -Utilisez l’[API publique W&B](/fr/models/ref/python/public-api/) pour référencer et télécharger un artifact sans initialiser un run. C’est utile dans des scénarios tels que les environnements distribués ou les workflows d’inférence, lorsque vous ne souhaitez pas créer de nouveau run. +Utilisez l’[API publique W&B](/fr/models/ref/python/public-api/) pour référencer et télécharger un artefact sans initialiser un run. C’est utile dans des scénarios tels que les environnements distribués ou lorsque vous effectuez de l’inférence, lorsque vous ne souhaitez pas créer de nouveau run. ```python import wandb @@ -434,10 +455,10 @@ artifact = wandb.Api().artifact("user/project/artifact:latest") local_path = artifact.download() ``` -Voir [Télécharger et utiliser des Artifacts](/fr/models/artifacts/download-and-use-an-artifact/) pour en savoir plus. +Pour plus d'informations, voir [Télécharger et utiliser des artefacts](/fr/models/artifacts/download-and-use-an-artifact/). -
+
## Ajuster les hyperparamètres
-Si votre bibliothèque prend en charge l’ajustement des hyperparamètres, vous pouvez intégrer [W&B Sweeps](/fr/models/sweeps/) pour gérer et visualiser les expériences. \ No newline at end of file +Si votre bibliothèque prend en charge l’ajustement des hyperparamètres, vous pouvez intégrer [W&B Sweeps](/fr/models/sweeps/) pour gérer et visualiser les expériences. Les balayages coordonnent plusieurs runs dans un espace de recherche défini et affichent les résultats dans W&B afin que les utilisateurs puissent comparer les configurations côte à côte. \ No newline at end of file diff --git a/fr/models/integrations/autotrain.mdx b/fr/models/integrations/autotrain.mdx index 72585f7d4b..745cc7d716 100644 --- a/fr/models/integrations/autotrain.mdx +++ b/fr/models/integrations/autotrain.mdx @@ -3,9 +3,11 @@ title: Hugging Face AutoTrain description: "Utilisez le suivi des expériences W&B avec Hugging Face AutoTrain pour entraîner des modèles sans code à l’aide d’un seul paramètre CLI." --- -[Hugging Face AutoTrain](https://huggingface.co/docs/autotrain/index) est un outil no-code permettant d’entraîner des modèles de pointe pour des tâches de traitement du langage naturel (NLP), de vision par ordinateur (CV), de parole, et même pour des tâches tabulaires. +[Hugging Face AutoTrain](https://huggingface.co/docs/autotrain/index) est un outil no-code permettant d’entraîner des modèles pour des tâches de traitement du langage naturel (NLP), de vision par ordinateur (CV), de parole et de données tabulaires. -[W&B](https://wandb.com/) est directement intégré à Hugging Face AutoTrain et fournit le suivi des expériences ainsi que la gestion de la configuration. Il vous suffit d’utiliser un seul paramètre dans la commande CLI pour vos expériences. +Hugging Face AutoTrain s’intègre directement à W&B pour le suivi des expériences et la gestion de la configuration. Il vous suffit d’utiliser un seul paramètre dans la commande CLI pour vos expériences. + +Cette page vous montre comment activer le suivi des expériences W&B lorsque vous entraînez un modèle avec Hugging Face AutoTrain. Vous pouvez capturer les métriques et la configuration pour chaque run sans écrire de code supplémentaire. Cette page s’adresse aux utilisateurs qui connaissent déjà AutoTrain et souhaitent ajouter de l’observabilité à leurs flux de travail d’entraînement. Journalisation des métriques des expériences @@ -15,7 +17,7 @@ description: "Utilisez le suivi des expériences W&B avec Hugging Face AutoTrain ## Installer les prérequis
-Installez `autotrain-advanced` et `wandb`. +Avant de pouvoir entraîner un modèle et journaliser les résultats dans W&B, installez la CLI AutoTrain et la bibliothèque cliente W&B. Installez `autotrain-advanced` et `wandb`. @@ -31,23 +33,25 @@ Installez `autotrain-advanced` et `wandb`. -Pour illustrer ces changements, cette page affine un LLM sur un jeu de données de mathématiques afin d’atteindre un résultat SoTA en `pass@1` sur les [benchmarks GSM8k](https://github.com/openai/grade-school-math). +Pour illustrer ces changements, cette page affine un LLM sur un jeu de données de mathématiques et évalue `pass@1` sur les [benchmarks GSM8k](https://github.com/openai/grade-school-math).
## Préparez le jeu de données
-Hugging Face AutoTrain exige que votre jeu de données CSV personnalisé respecte un format spécifique pour fonctionner correctement. +Avant l'entraînement, préparez votre jeu de données afin qu'il corresponde au format attendu par AutoTrain. Hugging Face AutoTrain exige que votre jeu de données CSV personnalisé respecte un format spécifique pour fonctionner correctement. -* Votre fichier d'entraînement doit contenir une colonne `text`, utilisée pour l'entraînement. Pour de meilleurs résultats, les données de la colonne `text` doivent respecter le format `### Human: Question?### Assistant: Answer.`. Consultez un excellent exemple dans [`timdettmers/openassistant-guanaco`](https://huggingface.co/datasets/timdettmers/openassistant-guanaco). +Votre fichier d'entraînement doit contenir une colonne `text`, utilisée pour l'entraînement. Les données de la colonne `text` doivent respecter le format `### Human: Question?### Assistant: Answer.`. Consultez un exemple dans [`timdettmers/openassistant-guanaco`](https://huggingface.co/datasets/timdettmers/openassistant-guanaco). - Cependant, le [jeu de données MetaMathQA](https://huggingface.co/datasets/meta-math/MetaMathQA) contient les colonnes `query`, `response` et `type`. Commencez par prétraiter ce jeu de données. Supprimez la colonne `type` et fusionnez le contenu des colonnes `query` et `response` dans une nouvelle colonne `text`, au format `### Human: Query?### Assistant: Response.`. Le jeu de données obtenu, [`rishiraj/guanaco-style-metamath`](https://huggingface.co/datasets/rishiraj/guanaco-style-metamath), est ensuite utilisé pour l'entraînement. +Cependant, le [jeu de données MetaMathQA](https://huggingface.co/datasets/meta-math/MetaMathQA) contient les colonnes `query`, `response` et `type`. Commencez par prétraiter ce jeu de données. Supprimez la colonne `type` et fusionnez le contenu des colonnes `query` et `response` dans une nouvelle colonne `text`, au format `### Human: Query?### Assistant: Response.`. Le jeu de données obtenu, [`rishiraj/guanaco-style-metamath`](https://huggingface.co/datasets/rishiraj/guanaco-style-metamath), est ensuite utilisé pour l'entraînement.
## Entraîner avec `autotrain`
-Vous pouvez démarrer l’entraînement avec `autotrain` advanced depuis la ligne de commande ou un notebook. Utilisez l’argument `--log`, ou `--log wandb` pour enregistrer vos résultats dans un [Run W&B](/fr/models/runs/). +Une fois votre environnement et votre dataset prêts, vous pouvez maintenant démarrer l’entraînement. Démarrez l’entraînement avec `autotrain` advanced depuis la ligne de commande ou un notebook. Utilisez l’argument `--log`, ou `--log wandb` pour journaliser vos résultats dans un [run](/fr/models/runs/). L’argument `--log wandb` active l’intégration W&B pour ce run. + +Remplacez `` par votre jeton d’accès Hugging Face et `` par l’adresse du dépôt cible (par exemple, `your-username/your-repo`). @@ -96,7 +100,7 @@ Vous pouvez démarrer l’entraînement avec `autotrain` advanced depuis la lign lora_dropout = 0.05 logging_steps = 10 - # Exécuter l’entraînement + # Lancer l’entraînement !autotrain llm \ --train \ --model "HuggingFaceH4/zephyr-7b-alpha" \ @@ -130,6 +134,8 @@ Vous pouvez démarrer l’entraînement avec `autotrain` advanced depuis la lign Sauvegarde de la configuration de l’expérience +Une fois l’entraînement démarré, AutoTrain journalise les métriques et la configuration de votre run dans W&B, où vous pouvez les consulter aux côtés de tous les autres runs de votre projet. +
## Autres ressources
diff --git a/fr/models/integrations/azure-openai-fine-tuning.mdx b/fr/models/integrations/azure-openai-fine-tuning.mdx index 50cc00631e..3ef869e464 100644 --- a/fr/models/integrations/azure-openai-fine-tuning.mdx +++ b/fr/models/integrations/azure-openai-fine-tuning.mdx @@ -1,22 +1,22 @@ --- -description: "Réalisez le Fine-tuning des modèles Azure OpenAI avec le suivi des expériences W&B afin de consigner les métriques, les hyperparamètres et la progression de l'entraînement." -title: Fine-tuning d’Azure OpenAI +description: "Effectuez le fine-tuning des modèles Azure OpenAI avec le suivi des expériences W&B pour consigner des métriques, des hyperparamètres et la progression de l'entraînement." +title: Fine-tuning Azure OpenAI --- -
- ## Introduction -
+Ce guide vous montre comment utiliser W&B avec Azure OpenAI pour suivre et évaluer les tâches de fine-tuning des modèles GPT-3.5 ou GPT-4. Lorsque vous intégrez W&B, le suivi des expériences consigne les métriques, les hyperparamètres et les artefacts d'entraînement afin de vous permettre d'analyser et d'améliorer les performances du modèle. Vous pouvez également utiliser les outils d'évaluation de W&B pour prendre des décisions fondées sur les données concernant la sélection du modèle. -Le fine-tuning de modèles GPT-3.5 ou GPT-4 sur Microsoft Azure avec W&B vous permet de suivre, d’analyser et d’améliorer les performances des modèles en capturant automatiquement les métriques et en facilitant une évaluation systématique grâce aux outils de suivi des expériences et d’évaluation de W&B. +Ce guide s'adresse aux professionnels du machine learning qui effectuent le fine-tuning de modèles Azure OpenAI et souhaitent disposer d'une méthode systématique pour suivre et comparer les exécutions. - Métriques de fine-tuning d’Azure OpenAI + Métriques de fine-tuning Azure OpenAI
## Prérequis
+Avant de commencer, effectuez les actions suivantes : + * Configurez le service Azure OpenAI en suivant la [documentation officielle d’Azure](https://wandb.me/aoai-wb-int). * Configurez un compte W&B à l’aide d’une clé API. @@ -24,44 +24,50 @@ Le fine-tuning de modèles GPT-3.5 ou GPT-4 sur Microsoft Azure avec W&B vou ## Aperçu du flux de travail -
- ### 1. Configuration du fine-tuning +Les étapes suivantes résument le déroulement typique d’un job de fine-tuning Azure OpenAI dans W&B, depuis la préparation du job jusqu’à l’évaluation du modèle obtenu. + +
+ ### Configuration du fine-tuning
-* Préparez les données d'entraînement conformément aux exigences d'Azure OpenAI. +La configuration du fine-tuning comprend les étapes suivantes : + +* Préparez les données d’entraînement conformément aux exigences d’Azure OpenAI. * Configurez le job de fine-tuning dans Azure OpenAI. -* W&B suit automatiquement le processus de fine-tuning et enregistre les métriques et les hyperparamètres. +* Suivez le processus de fine-tuning et consignez les métriques et les hyperparamètres avec W&B. -
- ### 2. Suivi des expériences +
+ ### Suivi des expériences
Lors du fine-tuning, W&B capture : -* Les métriques d'entraînement et de validation -* Les hyperparamètres du modèle -* L’utilisation des ressources -* Les Artifacts d'entraînement +* Les métriques d’entraînement et de validation. +* Les hyperparamètres du modèle. +* L’utilisation des ressources. +* Les artefacts d’entraînement. -
- ### 3. Évaluation du modèle +
+ ### Évaluation du modèle
Après le Fine-tuning, utilisez [W&B Weave](https://weave-docs.wandb.ai) pour : -* Évaluer les résultats du modèle à l’aide de jeux de données de référence -* Comparer les performances entre différentes itérations de Fine-tuning -* Analyser le comportement du modèle sur des cas de test spécifiques -* Prendre des décisions fondées sur les données pour choisir le modèle +* Évaluer les résultats du modèle à l’aide de jeux de données de référence. +* Comparer les performances entre différentes itérations de Fine-tuning. +* Analyser le comportement du modèle sur des cas de test spécifiques. +* Prendre des décisions fondées sur les données pour choisir le modèle.
## Exemple concret
+Pour voir l’intégration appliquée de bout en bout, explorez les ressources suivantes : + * Explorez la [démo de génération de notes médicales](https://wandb.me/aoai-ft-colab) pour voir comment cette intégration facilite : - * le suivi systématique des expériences de fine-tuning - * l’évaluation du modèle à l’aide de métriques propres au domaine -* Parcourez une [démo interactive de fine-tuning dans un notebook](https://colab.research.google.com/github/wandb/examples/blob/master/colabs/azure/azure_gpt_medical_notes.ipynb) + * le suivi systématique des expériences de fine-tuning. + * l’évaluation du modèle à l’aide de métriques propres au domaine. +* Parcourez un [notebook interactif de fine-tuning](https://colab.research.google.com/github/wandb/examples/blob/master/colabs/azure/azure_gpt_medical_notes.ipynb).
## Ressources supplémentaires diff --git a/fr/models/integrations/catalyst.mdx b/fr/models/integrations/catalyst.mdx index aaa74be71f..59bd8797ef 100644 --- a/fr/models/integrations/catalyst.mdx +++ b/fr/models/integrations/catalyst.mdx @@ -7,10 +7,10 @@ title: Catalyst Catalyst inclut une intégration W&B pour journaliser les paramètres, les métriques, les images et d’autres artefacts. -Consultez leur [documentation sur l’intégration](https://catalyst-team.github.io/catalyst/api/loggers.html#catalyst.loggers.wandb.WandbLogger), qui comprend des exemples en Python et avec Hydra. +Pour plus d’informations, notamment des exemples en Python et avec Hydra, consultez la [documentation sur l’intégration Catalyst](https://catalyst-team.github.io/catalyst/api/loggers.html#catalyst.loggers.wandb.WandbLogger).
## Exemple interactif
-Exécutez un [notebook Colab d’exemple](https://colab.research.google.com/drive/1PD0LnXiADCtt4mu7bzv7VfQkFXVrPxJq?usp=sharing) pour voir l’intégration entre Catalyst et W&B en action. \ No newline at end of file +Pour essayer l’intégration entre Catalyst et W&B, ouvrez le [notebook Colab d’exemple](https://colab.research.google.com/drive/1PD0LnXiADCtt4mu7bzv7VfQkFXVrPxJq?usp=sharing). \ No newline at end of file diff --git a/fr/models/integrations/cohere-fine-tuning.mdx b/fr/models/integrations/cohere-fine-tuning.mdx index 1ad822dbbe..bcf1a690ec 100644 --- a/fr/models/integrations/cohere-fine-tuning.mdx +++ b/fr/models/integrations/cohere-fine-tuning.mdx @@ -1,35 +1,35 @@ --- -description: "Effectuez le fine-tuning de modèles Cohere avec le suivi des expériences de W&B pour journaliser les métriques d'entraînement et surveiller les performances du modèle." +description: "Effectuez le fine-tuning de modèles Cohere avec le suivi des expériences de W&B afin de consigner les métriques d'entraînement et de surveiller les performances du modèle." title: fine-tuning Cohere --- -Avec W&B, vous pouvez journaliser les métriques de fine-tuning et la configuration de votre modèle Cohere afin d'analyser et de mieux comprendre les performances de vos modèles, puis de partager les résultats avec vos collègues. +Avec W&B, vous pouvez consigner les métriques et la configuration du fine-tuning de votre modèle Cohere afin d'analyser les performances du modèle et de partager les résultats avec vos collègues. Connectez un run de fine-tuning Cohere à un projet W&B, et W&B capture automatiquement les métriques d'entraînement et de validation, les hyperparamètres et les métadonnées du run dans votre espace de travail. Utilisez ce guide si vous effectuez déjà le fine-tuning de modèles Cohere et souhaitez centraliser le suivi des expériences. -Ce [guide de Cohere](https://docs.cohere.com/page/convfinqa-finetuning-wandb) contient un exemple complet montrant comment lancer un run de fine-tuning, et vous trouverez [ici la documentation de l'API Cohere](https://docs.cohere.com/reference/createfinetunedmodel#request.body.settings.wandb) +Pour obtenir un exemple complet de démarrage d'un run de fine-tuning, voir le [guide de fine-tuning Cohere](https://docs.cohere.com/page/convfinqa-finetuning-wandb) et se référer à la [référence de l'API Cohere pour le paramètre `wandb`](https://docs.cohere.com/reference/createfinetunedmodel#request.body.settings.wandb). -
- ## Journalisez les résultats de votre fine-tuning Cohere +
+ ## Journalisez les résultats du fine-tuning Cohere
-Pour ajouter la journalisation du fine-tuning Cohere à votre espace de travail W&B : +Pour ajouter la journalisation du fine-tuning Cohere à votre espace de travail W&B, procédez comme suit : -1. Créez un `WandbConfig` avec votre clé API W&B, votre `entity` W&B et le nom du `project`. Créez une clé API sur [https://wandb.ai/settings](https://wandb.ai/settings) +1. Créez un `WandbConfig` avec votre clé API W&B, votre `entity` W&B et le nom du `project`. La clé API authentifie le job Cohere auprès de W&B, et l'entité ainsi que le projet déterminent l'emplacement où W&B journalise vos runs. Créez une clé API dans vos [Paramètres utilisateur W&B](https://wandb.ai/settings). Remplacez `` dans l'exemple suivant par votre clé API. -2. Passez cette configuration à l'objet `FinetunedModel`, avec le nom de votre modèle, le jeu de données et les hyperparamètres, pour démarrer votre run de fine-tuning. +2. Passez cette configuration à l'objet `FinetunedModel`, avec le nom de votre modèle, le jeu de données et les hyperparamètres, pour démarrer votre run de fine-tuning. Le paramètre `wandb` configure Cohere pour transmettre les métriques à votre projet W&B pendant le run. ```python from cohere.finetuning import WandbConfig, FinetunedModel # créez une configuration avec vos informations W&B wandb_ft_config = WandbConfig( - api_key="", + api_key="", entity="my-entity", # doit être une entité valide associée à la clé API fournie project="cohere-ft", ) ... # configurez vos jeux de données et hyperparamètres - # démarrez un run de fine-tuning sur Cohere + # démarrez un run de fine-tuning sur cohere cmd_r_finetune = co.finetuning.create_finetuned_model( request=FinetunedModel( name="command-r-ft", @@ -49,16 +49,18 @@ Pour ajouter la journalisation du fine-tuning Cohere à votre espace de travail Tableau de bord du fine-tuning Cohere +Une fois le run démarré, votre job de fine-tuning Cohere transmet les métriques à W&B en temps réel, ce qui vous offre un emplacement unique pour comparer les runs et inspecter la progression de l'entraînement. +
## Organiser les runs
-Vos runs W&B sont automatiquement organisés et peuvent être filtrés/triés selon n’importe quel paramètre de configuration, comme le type de job, le modèle de base, le taux d’apprentissage ou tout autre hyperparamètre. +W&B organise automatiquement vos runs. Vous pouvez les filtrer et les trier selon n’importe quel paramètre de configuration, comme le type de job, le modèle de base, le taux d’apprentissage et tout autre hyperparamètre. -De plus, vous pouvez renommer vos runs, ajouter des notes ou créer des tags pour les regrouper. +Vous pouvez également renommer vos runs, ajouter des notes ou créer des tags pour les regrouper.
## Ressources
-* [Exemple de fine-tuning Cohere](https://github.com/cohere-ai/notebooks/blob/kkt_ft_cookbooks/notebooks/finetuning/convfinqa_finetuning_wandb.ipynb) \ No newline at end of file +Pour un exemple complet, voir le [notebook d’exemple de fine-tuning Cohere](https://github.com/cohere-ai/notebooks/blob/kkt_ft_cookbooks/notebooks/finetuning/convfinqa_finetuning_wandb.ipynb). \ No newline at end of file diff --git a/fr/models/integrations/composer.mdx b/fr/models/integrations/composer.mdx index 8557449c2b..cd160ff69b 100644 --- a/fr/models/integrations/composer.mdx +++ b/fr/models/integrations/composer.mdx @@ -7,14 +7,16 @@ import { ColabLink } from '/snippets/fr/_includes/colab-link.mdx'; -[Composer](https://github.com/mosaicml/composer) est une bibliothèque conçue pour entraîner des réseaux neuronaux plus efficacement, plus rapidement et à moindre coût. Elle propose de nombreuses méthodes de pointe pour accélérer l’entraînement des réseaux neuronaux et améliorer la généralisation, ainsi qu’une API [Trainer](https://docs.mosaicml.com/projects/composer/en/stable/trainer/using_the_trainer.html) facultative qui permet de *composer* facilement de nombreuses améliorations. +[Composer](https://github.com/mosaicml/composer) est une bibliothèque conçue pour entraîner des réseaux neuronaux plus efficacement, plus rapidement et à moindre coût. Elle comprend des méthodes pour accélérer l’entraînement et améliorer la généralisation. Composer dispose également d’une API [Trainer](https://docs.mosaicml.com/projects/composer/en/stable/trainer/using_the_trainer.html) facultative pour combiner de nombreuses améliorations différentes. -W&B fournit un wrapper léger pour consigner vos expériences de ML. Mais vous n’avez pas besoin de les combiner vous-même : W&B est directement intégré à la bibliothèque Composer via [WandBLogger](https://docs.mosaicml.com/projects/composer/en/stable/trainer/file_uploading.html#weights-biases-artifacts). +Utilisez W&B avec Composer pour suivre, visualiser et comparer vos runs d’entraînement. Composer inclut une journalisation W&B intégrée via [WandBLogger](https://docs.mosaicml.com/projects/composer/en/stable/trainer/file_uploading.html#weights-biases-artifacts).
## Commencez à journaliser avec W&B
+Pour commencer à journaliser vos runs d’entraînement Composer dans W&B, transmettez une instance de `composer.loggers.WandBLogger` à `composer.Trainer` : + ```python from composer import Trainer from composer.loggers import WandBLogger @@ -30,7 +32,9 @@ trainer = Trainer(..., logger=WandBLogger()) ## Utiliser le `WandBLogger` de Composer
-La bibliothèque Composer utilise la classe [WandBLogger](https://docs.mosaicml.com/projects/composer/en/stable/trainer/file_uploading.html#weights-biases-artifacts) dans le `Trainer` pour journaliser des métriques dans W&B. Il suffit d'instancier le logger et de le passer au `Trainer`. +Les sections suivantes décrivent comment le `WandBLogger` s’intègre au `Trainer` de Composer. + +La bibliothèque Composer utilise la classe [WandBLogger](https://docs.mosaicml.com/projects/composer/en/stable/trainer/file_uploading.html#weights-biases-artifacts) dans le `Trainer` pour journaliser des métriques dans W&B. Instanciez le logger et passez-le au `Trainer` : ```python wandb_logger = WandBLogger(project="gpt-5", log_artifacts=True) @@ -41,22 +45,11 @@ trainer = Trainer(logger=wandb_logger) ## Arguments du logger
-Vous trouverez ci-dessous les paramètres de `WandbLogger` ; consultez la [documentation Composer](https://docs.mosaicml.com/projects/composer/en/stable/api_reference/generated/composer.loggers.WandBLogger.html) pour obtenir la liste complète et leur description. - -| Paramètre | Description | -| ---------------- | ---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | -| `project` | Nom du projet W&B (str, facultatif) | -| `group` | Nom du groupe W&B (str, facultatif) | -| `name` | Nom de l'exécution W&B. S'il n'est pas spécifié, `State.run_name` est utilisé (str, facultatif) | -| `entity` | Nom de l'entité W&B, par exemple votre nom d'utilisateur ou votre nom Teams W&B (str, facultatif) | -| `tags` | Tags W&B (List[str], facultatif) | -| `log_artifacts` | Indique s'il faut journaliser les checkpoints dans wandb, par défaut : `false` (bool, facultatif) | -| `rank_zero_only` | Indique s'il faut journaliser uniquement sur le processus de rang zéro. Lors de la journalisation des Artifacts, il est fortement recommandé de journaliser sur tous les rangs. Les Artifacts des rangs ≥1 ne sont pas stockés, ce qui peut entraîner la perte d'informations pertinentes. Par exemple, lors de l'utilisation de Deepspeed ZeRO, il serait impossible de restaurer à partir des checkpoints sans les Artifacts de tous les rangs, par défaut : `True` (bool, facultatif) | -| `init_kwargs` | Paramètres à transmettre à `wandb.init()`, comme votre `config` wandb, entre autres. Voir les [paramètres de `wandb.init()`](/fr/models/ref/python/functions/init) pour les paramètres acceptés par `wandb.init()`. | +Pour connaître les paramètres que vous pouvez utiliser pour personnaliser la façon dont `WandBLogger` enregistre vos run, consultez la [documentation Composer](https://docs.mosaicml.com/projects/composer/en/stable/api_reference/generated/composer.loggers.WandBLogger.html). -Voici un exemple d’utilisation : +L’exemple suivant montre une utilisation typique qui transmet des notes d’exécution et un dictionnaire `config` via `init_kwargs` : -``` +```python init_kwargs = {"notes":"Testing higher learning rate in this experiment", "config":{"arch":"Llama", "use_mixed_precision":True @@ -70,7 +63,7 @@ wandb_logger = WandBLogger(log_artifacts=True, init_kwargs=init_kwargs) ## Journaliser des échantillons de prédictions
-Vous pouvez utiliser le système de [Callbacks de Composer](https://docs.mosaicml.com/projects/composer/en/stable/trainer/callbacks.html) pour contrôler quand vous journalisez dans W&B via le `WandBLogger` ; dans cet exemple, un échantillon d’images de validation et de prédictions est journalisé : +En plus des métriques scalaires, vous pouvez journaliser des médias enrichis, comme des prédictions de modèle, dans W&B pour un examen qualitatif. Vous pouvez utiliser le système de [callbacks de Composer](https://docs.mosaicml.com/projects/composer/en/stable/trainer/callbacks.html) pour contrôler à quel moment vous journalisez dans W&B avec `WandBLogger`. L’exemple suivant journalise un échantillon d’images de validation et de prédictions : ```python import wandb @@ -95,7 +88,7 @@ class LogPredictions(Callback): def eval_end(self, state: State, logger: Logger): with wandb.init() as run: - "Crée un wandb.Table et le journalise" + "Create a wandb.Table and logs it" columns = ['image', 'ground truth', 'prediction'] table = wandb.Table(columns=columns, data=self.data[:self.num_samples]) run.log({'sample_table':table}, step=int(state.timer.batch)) @@ -106,4 +99,4 @@ trainer = Trainer( loggers=[WandBLogger()], callbacks=[LogPredictions()] ) -``` +``` \ No newline at end of file diff --git a/fr/models/integrations/dagster.mdx b/fr/models/integrations/dagster.mdx index 8e9a0576a1..7263d8363b 100644 --- a/fr/models/integrations/dagster.mdx +++ b/fr/models/integrations/dagster.mdx @@ -3,9 +3,9 @@ description: "Intégrez W&B à Dagster pour suivre les expériences de ML et gé title: Dagster --- -Utilisez Dagster et W&B (W&B) pour orchestrer vos pipelines MLOps et gérer vos assets ML. L'intégration avec W&B facilite dans Dagster les opérations suivantes : +Utilisez Dagster et W&B ensemble pour orchestrer vos pipelines MLOps et gérer vos assets ML. Dans vos flux de travail Dagster existants, vous pouvez suivre les expériences, gérer les données et exécuter des tâches d'entraînement. L'intégration W&B prend en charge les tâches suivantes : -* Créer et utiliser un [W&B Artifact](/fr/models/artifacts). +* Créer et utiliser un [artefact W&B](/fr/models/artifacts). * Utiliser et créer des Registered Models dans [W&B Registry](/fr/models/registry). * Exécuter des tâches d'entraînement sur une infrastructure dédiée à l'aide de [W&B Launch](/fr/platform/launch). * Utiliser le client [wandb](/fr/models/ref/python) dans les ops et les assets. @@ -13,9 +13,9 @@ Utilisez Dagster et W&B (W&B) pour orchestrer vos pipelines MLOps et gé L'intégration W&B pour Dagster fournit une ressource Dagster spécifique à W&B et un IO Manager : * `wandb_resource` : une ressource Dagster utilisée pour s'authentifier auprès de l'API W&B et communiquer avec elle. -* `wandb_artifacts_io_manager` : un IO Manager Dagster utilisé pour consommer des W&B Artifacts. +* `wandb_artifacts_io_manager` : un IO Manager Dagster utilisé pour consommer des artefacts W&B. -Le guide suivant explique comment remplir les prérequis pour utiliser W&B dans Dagster, comment créer et utiliser des W&B Artifacts dans les ops et les assets, comment utiliser W&B Launch, ainsi que les bonnes pratiques recommandées. +Ce guide s'adresse aux praticiens du ML et aux ingénieurs plateforme qui utilisent déjà Dagster et souhaitent ajouter le suivi W&B et la gestion des artefacts. Vous apprendrez à configurer Dagster, à créer et utiliser des artefacts W&B dans les ops et les assets, à utiliser W&B Launch et à appliquer les bonnes pratiques.
## Avant de commencer @@ -23,25 +23,29 @@ Le guide suivant explique comment remplir les prérequis pour utiliser W&B d Vous aurez besoin des ressources suivantes pour utiliser Dagster dans W&B : -1. **Clé API W&B**. -2. **entité W&B (utilisateur ou équipe)** : une entité est un nom d’utilisateur ou un nom d’équipe auquel vous envoyez des Runs et des Artifacts W&B. Assurez-vous de créer votre compte ou votre entité d’équipe dans l’interface de l’application W&B avant d’enregistrer des runs. Si vous ne spécifiez pas d’entité, le run sera envoyé à votre entité par défaut, qui correspond généralement à votre nom d’utilisateur. Modifiez votre entité par défaut dans vos paramètres, sous **Valeurs par défaut du projet**. -3. **projet W&B** : le nom du projet dans lequel les [Runs W&B](/fr/models/runs) sont stockés. +* **Clé API W&B**. +* **entité W&B** : le nom de votre [équipe W&B](/fr/platform/hosting/iam/org_team_struct). +* **projet W&B** : le nom du projet dans lequel les [W&B Runs](/fr/models/runs) sont stockés. -Pour trouver votre entité W&B, consultez la page de profil de cet utilisateur ou de cette équipe dans l’application W&B. Vous pouvez utiliser un projet W&B existant ou en créer un nouveau. Vous pouvez créer de nouveaux projets sur la page d’accueil de l’application W&B ou sur la page de profil de l’utilisateur/de l’équipe. Si un projet n’existe pas, il sera automatiquement créé lorsque vous l’utiliserez pour la première fois. +Pour trouver votre entité W&B, consultez la page de profil de votre équipe dans W&B. Vous pouvez utiliser un projet W&B existant ou en créer un nouveau. Vous pouvez créer de nouveaux projets sur la page d’accueil de W&B ou sur la page de profil de votre équipe. Si un projet n’existe pas, W&B le crée automatiquement lorsque vous l’utilisez pour la première fois.
### Configurer votre clé API
-1. [Connectez-vous à W&B](https://wandb.ai/login). Remarque : si vous utilisez W&B Server, demandez à votre administrateur le nom d’hôte de l’instance. -2. Créez une clé API dans les [Paramètres utilisateur](https://wandb.ai/settings). Pour un environnement de production, nous vous recommandons d’utiliser un [compte de service](/fr/support/models/articles/what-is-a-service-account-and-why-is-it-) comme propriétaire de cette clé. -3. Définissez une variable d’environnement pour cette clé API : `export WANDB_API_KEY=YOUR_KEY`. +L’intégration s’authentifie auprès de W&B à l’aide d’une clé API, que vous devez rendre disponible pour Dagster sous forme de variable d’environnement. -Les exemples suivants montrent où spécifier votre clé API dans votre code Dagster. Veillez à renseigner votre entité et le nom de votre projet dans le dictionnaire imbriqué `wandb_config`. Vous pouvez transmettre des valeurs `wandb_config` différentes à différentes ops/assets si vous souhaitez utiliser un autre projet W&B. Pour plus d’informations sur les clés que vous pouvez transmettre, voir la section Configuration ci-dessous. +1. [Connectez-vous à W&B](https://wandb.ai/login). Si vous utilisez W&B Server, demandez à votre administrateur le nom d’hôte de l’instance. +2. Créez une clé API dans les [Paramètres utilisateur](https://wandb.ai/settings). Pour un environnement de production, utilisez un [compte de service](/fr/support/models/articles/what-is-a-service-account-and-why-is-it-) comme propriétaire de cette clé. +3. Définissez une variable d’environnement pour cette clé API : `export WANDB_API_KEY=`. + +Après avoir effectué ces étapes, Dagster peut lire votre clé API depuis l’environnement lorsqu’il charge `wandb_resource`. + +Les exemples suivants montrent où spécifier votre clé API dans votre code Dagster. Renseignez votre entité et le nom de votre projet dans le dictionnaire imbriqué `wandb_config`. Vous pouvez transmettre des valeurs `wandb_config` différentes à différentes ops ou assets si vous souhaitez utiliser un autre projet W&B. Pour plus d’informations sur les clés possibles que vous pouvez transmettre, voir la section [Configuration](#configuration). - Exemple : configuration pour `@job` + Exemple de configuration pour `@job` : ```python # ajoutez ceci à votre config.yaml @@ -72,7 +76,7 @@ Les exemples suivants montrent où spécifier votre clé API dans votre code Dag - Exemple : configuration pour `@repository` avec des assets + Exemple de configuration pour `@repository` avec des assets : ```python from dagster_wandb import wandb_artifacts_io_manager, wandb_resource @@ -114,7 +118,7 @@ Les exemples suivants montrent où spécifier votre clé API dans votre code Dag ] ``` - Notez que, dans cet exemple, nous configurons la durée du cache de l’IO Manager, contrairement à l’exemple pour `@job`. + Cet exemple configure la durée du cache de l’IO Manager, contrairement à l’exemple pour `@job`. @@ -122,27 +126,29 @@ Les exemples suivants montrent où spécifier votre clé API dans votre code Dag ### Configuration
-Les options de configuration suivantes servent de paramètres pour la ressource Dagster spécifique à W&B et l’IO Manager fourni par l’intégration. +L’intégration fournit une ressource Dagster spécifique à W&B ainsi qu’un IO Manager avec les options de configuration suivantes. * `wandb_resource` : [ressource](https://docs.dagster.io/guides/build/external-resources) Dagster utilisée pour communiquer avec l’API W&B. Elle s’authentifie automatiquement à l’aide de la clé API fournie. Propriétés : * `api_key` : (str, requis) : une clé API W&B nécessaire pour communiquer avec l’API W&B. * `host` : (str, facultatif) : le serveur hôte de l’API que vous souhaitez utiliser. Requis uniquement si vous utilisez W&B Server. Par défaut, l’hôte Public Cloud `https://api.wandb.ai` est utilisé. -* `wandb_artifacts_io_manager` : [IO Manager](https://docs.dagster.io/guides/build/io-managers) Dagster permettant de consommer des W&B Artifacts. Propriétés : - * `base_dir` : (int, facultatif) Répertoire de base utilisé pour le stockage local et la mise en cache. Les W&B Artifacts et les journaux des Runs W&B seront écrits dans ce répertoire et lus depuis celui-ci. Par défaut, le répertoire `DAGSTER_HOME` est utilisé. - * `cache_duration_in_minutes` : (int, facultatif) permet de définir la durée pendant laquelle les W&B Artifacts et les journaux des Runs W&B doivent être conservés dans le stockage local. Seuls les fichiers et répertoires qui n’ont pas été ouverts pendant cette durée sont supprimés du cache. La purge du cache a lieu à la fin de l’exécution de l’IO Manager. Vous pouvez définir cette valeur sur 0 si vous souhaitez désactiver complètement la mise en cache. La mise en cache accélère l’exécution lorsqu’un Artifact est réutilisé entre des jobs exécutés sur la même machine. La valeur par défaut est de 30 jours. - * `run_id` : (str, facultatif) : un ID unique pour ce run, utilisé pour la reprise. Il doit être unique dans le projet, et si vous supprimez un run, vous ne pouvez pas réutiliser cet ID. Utilisez le champ name pour un nom descriptif court, ou config pour enregistrer des hyperparamètres à comparer entre les runs. L’ID ne peut pas contenir les caractères spéciaux suivants : `/\#?%:..` Vous devez définir l’ID du run lorsque vous effectuez un suivi des expériences dans Dagster afin de permettre à l’IO Manager de reprendre le run. Par défaut, il est défini sur le Dagster ID du run, par exemple `7e4df022-1bf2-44b5-a383-bb852df4077e`. - * `run_name` : (str, facultatif) Un nom d’affichage court pour ce run afin de vous aider à l’identifier dans l’UI. Par défaut, il s’agit d’une chaîne au format suivant : `dagster-run-[8 premiers caractères du Dagster Run ID]`. Par exemple, `dagster-run-7e4df022`. - * `run_tags` : (list[str], facultatif) : une liste de chaînes qui alimentera la liste des tags de ce run dans l’UI. Les tags sont utiles pour regrouper des runs ou appliquer des étiquettes temporaires comme `baseline` ou `production`. Il est facile d’ajouter et de supprimer des tags dans l’UI, ou de filtrer pour n’afficher que les runs ayant un tag spécifique. Tout W&B Run utilisé par l’intégration aura le tag `dagster_wandb`. +* `wandb_artifacts_io_manager` : [IO Manager](https://docs.dagster.io/guides/build/io-managers) Dagster permettant d’utiliser des artefacts W&B. Propriétés : + * `base_dir` : (int, facultatif) Répertoire de base utilisé pour le stockage local et la mise en cache. Les artefacts W&B et les journaux des W&B Run sont écrits et lus dans ce répertoire. Par défaut, il utilise le répertoire `DAGSTER_HOME`. + * `cache_duration_in_minutes` : (int, facultatif) Définit la durée de conservation des artefacts W&B et des journaux des W&B Run dans le stockage local. Le cache supprime uniquement les fichiers et répertoires qui n’ont pas été ouverts pendant cette durée. La purge du cache a lieu à la fin de l’exécution d’un IO Manager. Définissez cette valeur sur 0 pour désactiver complètement la mise en cache. La mise en cache améliore les performances lorsqu’un artefact est réutilisé entre des jobs exécutés sur la même machine. La valeur par défaut est de 30 jours. + * `run_id` : (str, facultatif) : un ID unique pour ce run, utilisé pour la reprise. Il doit être unique dans le projet, et si vous supprimez un run, vous ne pouvez pas réutiliser cet ID. Utilisez le champ name pour un nom descriptif court, ou config pour enregistrer des hyperparamètres à comparer entre les runs. L’ID ne peut pas contenir les caractères spéciaux suivants : `/\#?%:..` Définissez le Run ID lorsque vous effectuez le suivi des expériences dans Dagster afin de permettre à l’IO Manager de reprendre le run. Par défaut, il est défini sur le Dagster Run ID, par exemple `7e4df022-1bf2-44b5-a383-bb852df4077e`. + * `run_name` : (str, facultatif) Nom d’affichage court pour ce run afin de vous aider à l’identifier dans l’interface utilisateur. Par défaut, il s’agit d’une chaîne au format suivant : `dagster-run-[8 premiers caractères du Dagster Run ID]`. Par exemple, `dagster-run-7e4df022`. + * `run_tags` : (list[str], facultatif) : liste de chaînes qui alimente la liste des tags de ce run dans l’interface utilisateur. Les tags sont utiles pour regrouper des runs ou appliquer des libellés temporaires comme `baseline` ou `production`. Vous pouvez ajouter et supprimer des tags dans l’interface utilisateur, ou filtrer les runs pour n’afficher que ceux ayant un tag spécifique. Tout W&B Run utilisé par l’intégration possède le tag `dagster_wandb`.
- ## Utiliser les W&B Artifacts + ## Utiliser les artefacts W&B
-L’intégration avec un W&B Artifact repose sur un Dagster IO Manager. +Cette section explique comment l’intégration utilise un Dagster IO Manager pour faire le lien entre les artefacts W&B et les ops et assets Dagster. + +L’intégration avec un artefact W&B repose sur un Dagster IO Manager. Les [IO Managers](https://docs.dagster.io/guides/build/io-managers) sont des objets fournis par l’utilisateur, chargés de stocker la sortie d’un asset ou d’une op, puis de la charger comme entrée pour les assets ou ops en aval. Par exemple, un IO Manager peut stocker et charger des objets à partir de fichiers sur un système de fichiers. -L’intégration fournit un IO Manager pour les W&B Artifacts. Cela permet à n’importe quel `@op` ou `@asset` Dagster de créer et de consommer des W&B Artifacts de manière native. Voici un exemple simple d’un `@asset` qui produit un W&B Artifact de type jeu de données contenant une liste Python. +L’intégration fournit un IO Manager pour les artefacts W&B. Cela permet à n’importe quel `@op` ou `@asset` Dagster de créer et de consommer directement des artefacts W&B. L’exemple suivant montre un `@asset` qui produit un artefact W&B de type jeu de données contenant une liste Python. ```python @asset( @@ -158,21 +164,23 @@ def create_dataset(): return [1, 2, 3] # ceci sera stocké dans un Artifact ``` -Vous pouvez annoter vos `@op`, `@asset` et `@multi_asset` avec une configuration de métadonnées pour écrire des Artifacts. De même, vous pouvez également consommer des W&B Artifacts même s’ils ont été créés en dehors de Dagster. +Vous pouvez annoter vos `@op`, `@asset` et `@multi_asset` avec une configuration de métadonnées pour écrire des Artifacts. De même, vous pouvez également consommer des artefacts W&B même s’ils ont été créés en dehors de Dagster.
- ## Écrire des W&B Artifacts + ## Écrire des artefacts W&B
-Avant de continuer, nous vous recommandons de bien comprendre comment utiliser les W&B Artifacts. Nous vous conseillons de lire le [Guide sur les Artifacts](/fr/models/artifacts). +Les sections suivantes décrivent comment produire des artefacts W&B à partir d’opérations et d’assets Dagster, y compris les types de retour pris en charge et la manière de configurer l’Artifact résultant. -Pour écrire un W&B Artifact, renvoyez un objet depuis une fonction Python. W&B prend en charge les objets suivants : +Avant de continuer, assurez-vous de bien comprendre comment utiliser les artefacts W&B. Voir le [Guide sur les Artifacts](/fr/models/artifacts). -* Objets Python (int, dict, list…) -* Objets W&B (Table, Image, Graph…) -* Objets W&B Artifact +Pour écrire un artefact W&B, renvoyez un objet depuis une fonction Python. W&B prend en charge les objets suivants : -Les exemples suivants montrent comment écrire des W&B Artifacts avec des assets Dagster (`@asset`) : +* Objets Python (`int`, `dict`, `list`, etc.) +* Objets W&B (Table, Image, Graph, etc.) +* Objets artefact W&B + +Les exemples suivants montrent comment écrire des artefacts W&B avec des assets Dagster (`@asset`) : @@ -215,7 +223,7 @@ Les exemples suivants montrent comment écrire des W&B Artifacts avec des as ``` - + Pour les cas d'utilisation complexes, il peut être nécessaire de créer votre propre objet Artifact. L'intégration fournit également des fonctionnalités supplémentaires utiles, comme l'enrichissement des métadonnées de part et d'autre de l'intégration. ```python @@ -240,7 +248,7 @@ Les exemples suivants montrent comment écrire des W&B Artifacts avec des as ### Configuration
-Un dictionnaire de configuration appelé wandb_artifact_configuration peut être défini pour `@op`, `@asset` et `@multi_asset`. Ce dictionnaire doit être transmis dans les arguments du décorateur en tant que métadonnées. Cette configuration est requise pour contrôler les lectures et écritures de l’IO Manager de W&B Artifacts. +Vous pouvez définir un dictionnaire de configuration appelé `wandb_artifact_configuration` pour `@op`, `@asset` et `@multi_asset`. Transmettez ce dictionnaire dans les arguments du décorateur en tant que métadonnées. Cette configuration est requise pour contrôler les lectures et écritures de l’IO Manager des artefacts W&B. Pour `@op`, il se trouve dans les métadonnées de sortie via l’argument de métadonnées [Out](https://docs.dagster.io/_apidocs/ops#dagster.Out). Pour `@asset`, il se trouve dans l’argument `metadata` de l’asset. @@ -285,7 +293,7 @@ Les exemples de code ci-dessous montrent comment configurer un dictionnaire pour return [1, 2, 3] ``` - Vous n’avez pas besoin de transmettre un nom dans la configuration, car `@asset` en a déjà un. L’intégration définit le nom de l’Artifact sur celui de l’asset. + Vous n’avez pas besoin de transmettre un nom dans la configuration, car `@asset` en a déjà un. L’intégration définit le nom de l’artefact W&B sur celui de l’asset. @@ -323,15 +331,15 @@ Les exemples de code ci-dessous montrent comment configurer un dictionnaire pour -Propriétés prises en charge : +Les propriétés suivantes sont prises en charge : -* `name`: (str) nom lisible par l’humain pour cet artifact, ce qui vous permet d’identifier cet artifact dans l’UI ou d’y faire référence dans les appels `use_artifact`. Les noms peuvent contenir des lettres, des chiffres, des underscores, des traits d’union et des points. Le nom doit être unique à l’échelle d’un projet. Requis pour `@op`. +* `name`: (str) nom lisible par l’humain pour cet artifact, que vous pouvez utiliser pour l’identifier dans l’UI ou y faire référence dans les appels `use_artifact`. Les noms peuvent contenir des lettres, des chiffres, des underscores, des traits d’union et des points. Le nom doit être unique à l’échelle d’un projet. Requis pour `@op`. * `type`: (str) type de l’artifact, utilisé pour organiser et différencier les artifacts. Les types courants incluent les jeux de données ou les modèles, mais vous pouvez utiliser n’importe quelle chaîne contenant des lettres, des chiffres, des underscores, des traits d’union et des points. Requis lorsque la sortie n’est pas déjà un Artifact. -* `description`: (str) Texte libre qui décrit l’artifact. La description est interprétée en markdown dans l’UI, c’est donc un bon endroit pour ajouter des tableaux, des liens, etc. -* `aliases`: (list[str]) Un tableau contenant un ou plusieurs alias que vous souhaitez appliquer à l’Artifact. L’intégration ajoutera également le tag “latest” à cette liste, qu’il soit défini ou non. C’est un moyen efficace de gérer les versions des modèles et des jeux de données. -* [`add_dirs`](/fr/models/ref/python/experiments/artifact#add_dir): (list[dict[str, Any]]): Un tableau contenant la configuration de chaque répertoire local à inclure dans l’Artifact. -* [`add_files`](/fr/models/ref/python/experiments/artifact#add_file): (list[dict[str, Any]]): Un tableau contenant la configuration de chaque fichier local à inclure dans l’Artifact. -* [`add_references`](/fr/models/ref/python/experiments/artifact#add_reference): (list[dict[str, Any]]): Un tableau contenant la configuration de chaque référence externe à inclure dans l’Artifact. +* `description`: (str) Texte libre qui décrit l’artifact. La description est interprétée en markdown dans l’UI, c’est donc un bon endroit pour les tableaux, les liens, etc. +* `aliases`: (list[str]) Un tableau contenant un ou plusieurs alias que vous souhaitez appliquer à l’artefact W&B. L’intégration ajoute également le tag "latest" à cette liste, qu’il soit défini ou non. Utilisez les alias pour gérer les versions des modèles et des jeux de données. +* [`add_dirs`](/fr/models/ref/python/experiments/artifact#add_dir): (list[dict[str, Any]]): Un tableau contenant la configuration de chaque répertoire local à inclure dans l’artefact W&B. +* [`add_files`](/fr/models/ref/python/experiments/artifact#add_file): (list[dict[str, Any]]): Un tableau contenant la configuration de chaque fichier local à inclure dans l’artefact W&B. +* [`add_references`](/fr/models/ref/python/experiments/artifact#add_reference): (list[dict[str, Any]]): Un tableau contenant la configuration de chaque référence externe à inclure dans l’artefact W&B. * `serialization_module`: (dict) Configuration du module de sérialisation à utiliser. Se référer à la section Serialization pour plus d’informations. * `name`: (str) Nom du module de sérialisation. Valeurs acceptées : `pickle`, `dill`, `cloudpickle`, `joblib`. Le module doit être disponible localement. * `parameters`: (dict[str, Any]) Arguments facultatifs transmis à la fonction de sérialisation. Elle accepte les mêmes paramètres que la méthode `dump` de ce module. Par exemple, `{"compress": 3, "protocol": 4}`. @@ -380,34 +388,34 @@ def create_advanced_artifact(): return [1, 2, 3] ``` -L'asset est matérialisé avec des métadonnées utiles de part et d'autre de l'intégration : +L'asset est matérialisé avec des métadonnées de part et d'autre de l'intégration : * Côté W&B : le nom et la version de l'intégration source, la version de Python utilisée, la version du protocole pickle, entre autres. * Côté Dagster : * ID du run Dagster - * Run W&B : ID, nom, chemin, URL - * W&B Artifact : ID, nom, type, version, taille, URL + * W&B Run : ID, nom, chemin, URL + * artefact W&B : ID, nom, type, version, taille, URL * Entité W&B * Projet W&B -L'image suivante montre les métadonnées issues de W&B qui ont été ajoutées à l'asset Dagster. Ces informations sont transmises à Dagster par l'intégration. +L'image suivante montre les métadonnées issues de W&B que l'intégration ajoute à l'asset Dagster. L'intégration transmet ces informations à Dagster. UI de Dagster avec une vue détaillée d'un asset et des métadonnées W&B associées, y compris des références à un projet et à un run W&B -L'image suivante montre comment la configuration fournie a été enrichie avec des métadonnées utiles dans le W&B Artifact. Ces informations devraient faciliter la reproductibilité et la maintenance. Elles ne seraient pas disponibles sans l'intégration. +L'image suivante montre comment la configuration fournie est enrichie avec des métadonnées dans l’artefact W&B. Ces informations facilitent la reproductibilité et la maintenance. Elles ne sont pas disponibles sans l'intégration. - Page de W&B Artifact avec des métadonnées de configuration enrichies provenant de Dagster + Page de l’artefact W&B avec des métadonnées de configuration enrichies provenant de Dagster - Panneau de métadonnées du W&B Artifact avec des détails de configuration supplémentaires provenant de Dagster + Panneau de métadonnées de l’artefact W&B avec des détails de configuration supplémentaires provenant de Dagster - Vue du W&B Artifact avec des champs de métadonnées de configuration supplémentaires enrichis depuis Dagster + Vue de l’artefact W&B avec des champs de métadonnées de configuration supplémentaires enrichis depuis Dagster @@ -418,11 +426,13 @@ L'image suivante montre comment la configuration fournie a été enrichie av ``` -### Utiliser les partitions +
+ ### Utiliser les partitions +
-L’intégration prend nativement en charge les [partitions Dagster](https://docs.dagster.io/guides/build/partitions-and-backfills). +L’intégration prend directement en charge les [partitions Dagster](https://docs.dagster.io/guides/build/partitions-and-backfills). -Voici un exemple de partitionnement avec `DailyPartitionsDefinition`. +Voici un exemple de partitionnement avec `DailyPartitionsDefinition` : ```python @asset( @@ -441,10 +451,10 @@ def create_my_daily_partitioned_asset(context): return random.randint(0, 100) ``` -Ce code produira un W&B Artifact pour chaque partition. Consultez les Artifacts dans le panneau Artifact (UI), sous le nom de l’asset, avec la clé de partition ajoutée. Par exemple, `my_daily_partitioned_asset.2023-01-01`, `my_daily_partitioned_asset.2023-01-02` ou `my_daily_partitioned_asset.2023-01-03`. Les assets partitionnés sur plusieurs dimensions affichent chaque dimension dans un format délimité par des points. Par exemple, `my_asset.car.blue`. +Ce code produit un artefact W&B pour chaque partition. Consultez les Artifacts dans le panneau Artifact (UI), sous le nom de l’asset, avec la clé de partition ajoutée. Par exemple, `my_daily_partitioned_asset.2023-01-01`, `my_daily_partitioned_asset.2023-01-02` ou `my_daily_partitioned_asset.2023-01-03`. Les assets partitionnés sur plusieurs dimensions affichent chaque dimension dans un format délimité par des points. Par exemple, `my_asset.car.blue`. - L’intégration ne permet pas de matérialiser plusieurs partitions au sein d’un même run. Vous devrez effectuer plusieurs runs pour matérialiser vos assets. Vous pouvez le faire dans Dagit lorsque vous matérialisez vos assets. + L’intégration ne permet pas de matérialiser plusieurs partitions au sein d’un même run. Vous devez effectuer plusieurs runs pour matérialiser vos assets. Vous pouvez le faire dans Dagit lorsque vous matérialisez vos assets. Interface Dagster avec plusieurs runs pour des assets partitionnés, chaque partition correspondant à un run distinct @@ -455,6 +465,8 @@ Ce code produira un W&B Artifact pour chaque partition. Consultez les Artifa #### Utilisation avancée
+Pour une utilisation avancée, voir les exemples suivants : + * [job partitionné](https://github.com/dagster-io/dagster/blob/master/examples/with_wandb/with_wandb/ops/partitioned_job.py) * [asset partitionné simple](https://github.com/wandb/dagster/blob/master/examples/with_wandb/with_wandb/assets/simple_partitions_example.py) * [asset partitionné multi-dimensionnel](https://github.com/wandb/dagster/blob/master/examples/with_wandb/with_wandb/assets/multi_partitions_example.py) @@ -464,12 +476,14 @@ Ce code produira un W&B Artifact pour chaque partition. Consultez les Artifa ## Lire Artifacts W&B +Maintenant que vous pouvez écrire des Artifacts depuis Dagster, les sections suivantes décrivent comment les utiliser comme entrées pour des ops et assets en aval. + La lecture des Artifacts W&B est similaire à leur écriture. Un dictionnaire de configuration appelé `wandb_artifact_configuration` peut être défini sur un `@op` ou un `@asset`. La seule différence est que la configuration doit être définie sur l’entrée plutôt que sur la sortie. Pour `@op`, elle se trouve dans les métadonnées d’entrée via l’argument de métadonnées [In](https://docs.dagster.io/_apidocs/ops#dagster.In). Vous devez -indiquer explicitement le nom de l’Artifact. +indiquer explicitement le nom de l’artefact W&B. -Pour `@asset`, elle se trouve dans les métadonnées d’entrée via l’argument de métadonnées [Asset](https://docs.dagster.io/_apidocs/assets#dagster.AssetIn) In. Vous ne devez pas transmettre de nom d’Artifact, car le nom de l’asset parent doit correspondre. +Pour `@asset`, elle se trouve dans les métadonnées d’entrée via l’argument de métadonnées [Asset](https://docs.dagster.io/_apidocs/assets#dagster.AssetIn) In. Vous ne devez pas transmettre de nom d’artefact W&B, car le nom de l’asset parent doit correspondre. Si vous souhaitez créer une dépendance sur un Artifact créé en dehors de l’intégration, vous devrez utiliser [SourceAsset](https://docs.dagster.io/_apidocs/assets#dagster.SourceAsset). Il lira toujours la dernière version de cet asset. @@ -538,9 +552,9 @@ Les exemples suivants montrent comment lire un Artifact à partir de différents ### Configuration -La configuration suivante sert à indiquer ce que l’IO Manager doit collecter et fournir en entrée aux fonctions décorées. Les modes de lecture suivants sont pris en charge. +La configuration suivante indique ce que l’IO Manager doit collecter et fournir en entrée aux fonctions décorées. Les modes de lecture suivants sont pris en charge : -1. Pour obtenir un objet nommé contenu dans un Artifact, utilisez `get` : +* Pour obtenir un objet nommé contenu dans un Artifact, utilisez `get` : ```python @asset( @@ -560,7 +574,7 @@ def get_table(context, table): context.log.info(table.get_column("a")) ``` -2. Pour obtenir le chemin local d’un fichier téléchargé présent dans un Artifact, utilisez get_path : +* Pour obtenir le chemin local d’un fichier téléchargé présent dans un Artifact, utilisez `get_path` : ```python @asset( @@ -580,7 +594,7 @@ def get_path(context, path): context.log.info(path) ``` -3. Pour obtenir l’objet Artifact dans son intégralité (avec le contenu téléchargé localement) : +* Pour obtenir l’objet Artifact dans son intégralité (avec le contenu téléchargé localement) : ```python @asset( @@ -595,7 +609,7 @@ def get_artifact(context, artifact): context.log.info(artifact.name) ``` -Propriétés prises en charge +Les propriétés suivantes sont prises en charge : * `get`: (str) Obtient l'objet W&B correspondant au nom relatif de l'artifact. * `get_path`: (str) Obtient le chemin du fichier correspondant au nom relatif de l'artifact. @@ -606,23 +620,23 @@ Propriétés prises en charge Par défaut, l’intégration utilise le module standard [pickle](https://docs.python.org/3/library/pickle.html), mais certains objets ne sont pas compatibles avec celui-ci. Par exemple, les fonctions contenant `yield` génèrent une erreur si vous essayez de les sérialiser avec pickle. -Nous prenons également en charge d’autres modules de sérialisation basés sur Pickle ([dill](https://github.com/uqfoundation/dill), [cloudpickle](https://github.com/cloudpipe/cloudpickle), [joblib](https://github.com/joblib/joblib)). Vous pouvez aussi utiliser des méthodes de sérialisation plus avancées comme [ONNX](https://onnx.ai/) ou [PMML](https://en.wikipedia.org/wiki/Predictive_Model_Markup_Language), en renvoyant une chaîne sérialisée ou en créant directement un Artifact. Le choix le plus adapté dépend de votre cas d’usage ; veuillez vous référer à la documentation disponible sur ce sujet. +W&B prend également en charge d’autres modules de sérialisation basés sur Pickle ([dill](https://github.com/uqfoundation/dill), [cloudpickle](https://github.com/cloudpipe/cloudpickle), [joblib](https://github.com/joblib/joblib)). Vous pouvez aussi utiliser des méthodes de sérialisation plus avancées comme [ONNX](https://onnx.ai/) ou [PMML](https://en.wikipedia.org/wiki/Predictive_Model_Markup_Language), en renvoyant une chaîne sérialisée ou en créant directement un Artifact. Le choix le plus adapté dépend de votre cas d’usage. Veuillez vous référer à la documentation disponible sur ce sujet.
### Modules de sérialisation basés sur pickle
- Le pickling est réputé non sécurisé. Si la sécurité est un enjeu, utilisez uniquement des objets W&B. Nous vous recommandons de signer vos données et de stocker les clés de hachage dans vos propres systèmes. Pour des cas d’usage plus complexes, n’hésitez pas à nous contacter : nous serons ravis de vous aider. + Le pickling est réputé non sécurisé. Si la sécurité est un enjeu, utilisez uniquement des objets W&B. Signez vos données et stockez les clés de hachage dans vos propres systèmes. Pour des cas d’usage plus complexes, contactez l’assistance W&B. Vous pouvez configurer la sérialisation utilisée via le dictionnaire `serialization_module` dans `wandb_artifact_configuration`. Assurez-vous que le module est disponible sur la machine exécutant Dagster. -L’intégration saura automatiquement quel module de sérialisation utiliser lorsque vous lirez cet Artifact. +L’intégration détecte automatiquement quel module de sérialisation utiliser lorsque vous lirez cet Artifact. -Les modules actuellement pris en charge sont `pickle`, `dill`, `cloudpickle` et `joblib`. +Les modules pris en charge sont `pickle`, `dill`, `cloudpickle` et `joblib`. -Voici un exemple simplifié dans lequel nous créons un « modèle » sérialisé avec joblib, puis l’utilisons pour l’inférence. +Voici un exemple simplifié qui crée un « modèle » sérialisé avec joblib, puis l’utilise pour l’inférence. ```python @asset( @@ -669,12 +683,12 @@ def use_model_serialized_with_joblib( ### Formats de sérialisation avancés (ONNX, PMML) -Il est courant d’utiliser des formats de fichier d’échange comme ONNX et PMML. L’intégration prend en charge ces formats, mais cela demande un peu plus de travail qu’une sérialisation basée sur Pickle. +Les formats de fichier d’échange comme ONNX et PMML sont courants. L’intégration prend en charge ces formats, mais cela demande un peu plus de travail qu’une sérialisation basée sur Pickle. -Il existe deux méthodes pour utiliser ces formats. +Vous pouvez utiliser ces formats avec l’une des méthodes suivantes : -1. Convertissez votre modèle dans le format sélectionné, puis renvoyez sa représentation sous forme de chaîne comme s’il s’agissait d’un objet Python ordinaire. L’intégration sérialisera cette chaîne avec pickle. Vous pourrez ensuite reconstruire votre modèle à partir de cette chaîne. -2. Créez un nouveau fichier local contenant votre modèle sérialisé, puis créez un Artifact personnalisé avec ce fichier à l’aide de la configuration add_file. +* Convertissez votre modèle dans le format sélectionné, puis renvoyez sa représentation sous forme de chaîne comme s’il s’agissait d’un objet Python ordinaire. L’intégration sérialise cette chaîne avec pickle. Vous pourrez ensuite reconstruire votre modèle à partir de cette chaîne. +* Créez un nouveau fichier local contenant votre modèle sérialisé, puis créez un Artifact personnalisé avec ce fichier à l’aide de la configuration `add_file`. Voici un exemple de modèle Scikit-learn sérialisé avec ONNX. @@ -755,11 +769,9 @@ def use_onnx_model(context, my_onnx_model, my_test_set): return pred_onx ``` -
- ### Utilisation des partitions -
+### Utiliser des partitions -L’intégration prend nativement en charge les [partitions Dagster](https://docs.dagster.io/guides/build/partitions-and-backfills). +L’intégration prend directement en charge les [partitions Dagster](https://docs.dagster.io/guides/build/partitions-and-backfills). Vous pouvez lire une, plusieurs ou toutes les partitions d’un asset de manière sélective. @@ -782,7 +794,7 @@ Toutes les partitions sont fournies dans un dictionnaire, où la clé et la vale
- La configuration `partition_mapping` de `AssetIn` vous permet de sélectionner des partitions spécifiques. Dans ce cas, nous utilisons `TimeWindowPartitionMapping`. + La configuration `partition_mapping` de `AssetIn` vous permet de sélectionner des partitions spécifiques. Dans ce cas, l’exemple utilise `TimeWindowPartitionMapping`. ```python @asset( @@ -802,26 +814,29 @@ Toutes les partitions sont fournies dans un dictionnaire, où la clé et la vale
-L’objet de configuration `metadata` détermine comment W&B interagit avec les différentes partitions d’artifact dans votre projet. +L’objet de configuration `metadata` détermine comment W&B interagit avec les différentes partitions d’artefact W&B dans votre projet. L’objet `metadata` contient une clé nommée `wandb_artifact_configuration`, qui contient elle-même un objet imbriqué `partitions`. L’objet `partitions` associe le nom de chaque partition à sa configuration. La configuration de chaque partition peut préciser comment récupérer ses données. Ces configurations peuvent contenir différentes clés, à savoir `get`, `version` et `alias`, selon les exigences de chaque partition. -**Clés de configuration** +
+ #### Clés de configuration +
-1. `get`: - La clé `get` spécifie le nom de l’objet W&B (Table, Image...) depuis lequel récupérer les données. -2. `version`: - La clé `version` est utilisée lorsque vous souhaitez récupérer une version spécifique de l’Artifact. -3. `alias`: - La clé `alias` vous permet d’obtenir l’Artifact via son alias. +Les clés de configuration suivantes sont prises en charge : -**Configuration générique** +* `get` : La clé `get` spécifie le nom de l’objet W&B (Table, Image, etc.) à partir duquel récupérer les données. +* `version` : Utilisez la clé `version` lorsque vous souhaitez récupérer une version spécifique de l’Artifact. +* `alias` : La clé `alias` vous permet d’obtenir l’Artifact à l’aide de son alias. + +
+ #### Configuration générique +
Le caractère générique `"*"` désigne toutes les partitions non configurées. Il fournit une configuration par défaut pour les partitions qui ne sont pas explicitement mentionnées dans l’objet `partitions`. -Par exemple, +Par exemple : ```python "*": { @@ -831,11 +846,13 @@ Par exemple, Cette configuration signifie que, pour toutes les partitions non configurées explicitement, les données sont récupérées depuis le tableau nommé `default_table_name`. -**Configuration spécifique de partition** +
+ #### Configuration spécifique de partition +
Vous pouvez remplacer la configuration générique pour certaines partitions en fournissant leur propre configuration à l’aide de leur clé. -Par exemple, +Par exemple : ```python "yellow": { @@ -843,13 +860,15 @@ Par exemple, }, ``` -Cette configuration signifie que, pour la partition nommée `yellow`, les données seront récupérées depuis la table nommée `custom_table_name`, en remplaçant la configuration générique. +Cette configuration signifie que, pour la partition nommée `yellow`, les données sont récupérées depuis le tableau nommé `custom_table_name`, ce qui remplace la configuration générique. -**Gestion des versions et des alias** +
+ #### Gestion des versions et des alias +
À des fins de gestion des versions et des alias, vous pouvez spécifier des clés `version` et `alias` spécifiques dans votre configuration. -Pour les versions, +Pour les versions : ```python "orange": { @@ -859,7 +878,7 @@ Pour les versions, Cette configuration récupérera les données de la partition de l’Artifact `orange` en version `v0`. -Pour les alias, +Pour les alias : ```python "blue": { @@ -867,7 +886,7 @@ Pour les alias, }, ``` -Cette configuration récupérera des données depuis le tableau `default_table_name` de la partition Artifact avec l'alias `special_alias` (désigné par `blue` dans la configuration). +Cette configuration récupère des données depuis le tableau `default_table_name` de la partition Artifact avec l'alias `special_alias` (désigné par `blue` dans la configuration). ### Utilisation avancée @@ -877,17 +896,19 @@ Pour consulter des cas d’utilisation avancée de l’intégration, se référe * [Exemple de job partitionné](https://github.com/dagster-io/dagster/blob/master/examples/with_wandb/with_wandb/ops/partitioned_job.py) * [Associer un modèle au registre de modèles](https://github.com/dagster-io/dagster/blob/master/examples/with_wandb/with_wandb/assets/model_registry_example.py) -
+
## Utiliser W&B Launch
+Les sections suivantes décrivent comment combiner l’intégration Dagster avec W&B Launch pour exécuter des tâches d'entraînement sur du calcul dédié, localement ou à distance. + - Produit bêta en cours de développement actif + Produit bêta en cours de développement actif. Launch vous intéresse ? Contactez l’équipe en charge de votre compte pour discuter de votre participation au programme pilote client de W&B Launch. - Les clients pilotes doivent utiliser AWS EKS ou SageMaker pour être éligibles au programme bêta. À terme, nous prévoyons de prendre en charge d’autres plateformes. + Les clients pilotes doivent utiliser AWS EKS ou SageMaker pour être éligibles au programme bêta. D’autres plateformes sont prévues. -Avant de continuer, nous vous recommandons de bien comprendre comment utiliser W&B Launch. Nous vous conseillons de lire le [Guide de Launch](/fr/platform/launch). +Avant de continuer, assurez-vous de bien comprendre comment utiliser W&B Launch. Voir le [Guide de Launch](/fr/platform/launch). L’intégration Dagster permet de : @@ -905,13 +926,13 @@ Les agents sont des processus qui interrogent les files d’attente de Launch et Référez-vous à la [page Launch](/fr/platform/launch). -Vous pouvez également consulter des descriptions utiles pour toutes les propriétés dans Launchpad. +Vous pouvez également consulter les descriptions de toutes les propriétés dans Launchpad. Interface W&B Launchpad avec les options de configuration de l’agent et les descriptions pour l’intégration Dagster -Exemple simple +Exemple : ```python # ajoutez ceci à votre config.yaml @@ -955,17 +976,17 @@ def run_launch_agent_example(): L’intégration fournit un `@op` importable appelé `run_launch_job`. Il exécute votre job Launch. -Pour être exécuté, un job Launch doit être assigné à une file d’attente. Vous pouvez créer une file d’attente ou utiliser celle par défaut. Assurez-vous qu’un agent actif écoute cette file d’attente. Vous pouvez exécuter un agent dans votre instance Dagster, mais vous pouvez aussi envisager d’utiliser un agent déployable sur Kubernetes. +Pour être exécuté, un job Launch doit être assigné à une file d’attente. Vous pouvez créer une file d’attente ou utiliser celle par défaut. Assurez-vous qu’un agent actif écoute cette file d’attente. Vous pouvez exécuter un agent dans votre instance Dagster, ou envisager d’utiliser un agent déployable sur Kubernetes. Consultez la [page Launch](/fr/platform/launch). -Vous pouvez également consulter dans Launchpad des descriptions utiles pour toutes les propriétés. +Vous pouvez également consulter dans Launchpad des descriptions pour toutes les propriétés. Interface W&B Launchpad avec des options de configuration de job et des descriptions pour l’intégration Dagster -Exemple simple +Exemple : ```python # ajoutez ceci à votre config.yaml @@ -1010,29 +1031,52 @@ def run_launch_job_example(): ## Bonnes pratiques
-1. Utilisez l’IO Manager pour lire et écrire des Artifacts. - Évitez d’utiliser directement [`Artifact.download()`](/fr/models/ref/python/experiments/artifact#download) ou [`Run.log_artifact()`](/fr/models/ref/python/experiments/run#log_artifact). Ces méthodes sont prises en charge par l’intégration. Renvoyez plutôt les données que vous souhaitez stocker dans l’Artifact et laissez l’intégration faire le reste. Cette approche offre une meilleure traçabilité pour l’Artifact. +Les recommandations suivantes vous aident à tirer le meilleur parti de l’intégration une fois qu’elle est opérationnelle de bout en bout. -2. Ne créez vous-même un objet Artifact que pour des cas d’usage complexes. - Les objets Python et les objets W&B doivent être renvoyés depuis vos ops/assets. L’intégration se charge d’assembler l’Artifact. - Pour les cas d’usage complexes, vous pouvez créer un Artifact directement dans un job Dagster. Nous vous recommandons de transmettre un objet Artifact à l’intégration pour enrichir les métadonnées, par exemple avec le nom et la version de l’intégration source, la version de Python utilisée, la version du protocole pickle, etc. +
+ ### Utilisez l’IO Manager pour lire et écrire des Artifacts +
-3. Ajoutez des fichiers, des répertoires et des références externes à vos Artifacts via les métadonnées. - Utilisez l’objet d’intégration `wandb_artifact_configuration` pour ajouter des fichiers, des répertoires ou des références externes (Amazon S3, GCS, HTTP…). Voir l’exemple avancé dans la [section de configuration de l’Artifact](#configuration-1) pour plus d’informations. +Évitez d’utiliser directement [`Artifact.download()`](/fr/models/ref/python/experiments/artifact#download) ou [`Run.log_artifact()`](/fr/models/ref/python/experiments/run#log_artifact). Ces méthodes sont prises en charge par l’intégration. Renvoyez plutôt les données que vous souhaitez stocker dans l’Artifact et laissez l’intégration faire le reste. Cette approche offre une meilleure traçabilité pour l’Artifact. -4. Utilisez un @asset plutôt qu’un @op lorsqu’un Artifact est produit. - Les Artifacts sont des assets. Il est recommandé d’utiliser un asset lorsque Dagster gère cet asset. Cela offre une meilleure observabilité dans le catalogue d’assets de Dagit. +
+ ### Ne créez vous-même un objet Artifact que pour des cas d’usage complexes +
-5. Utilisez un SourceAsset pour consommer un Artifact créé en dehors de Dagster. - Cela vous permet de tirer parti de l’intégration pour lire des Artifacts créés hors de Dagster. Sinon, vous ne pouvez utiliser que les Artifacts créés par l’intégration. +Renvoyez des objets Python et des objets W&B depuis vos ops et assets. L’intégration se charge d’assembler l’Artifact. +Pour les cas d’usage complexes, vous pouvez créer un Artifact directement dans un job Dagster. Transmettez un objet Artifact à l’intégration pour enrichir les métadonnées, par exemple avec le nom et la version de l’intégration source, la version de Python utilisée, la version du protocole pickle, etc. -6. Utilisez W&B Launch pour orchestrer l’entraînement sur des ressources de calcul dédiées pour les grands modèles. - Vous pouvez entraîner de petits modèles dans votre cluster Dagster, et exécuter Dagster dans un cluster Kubernetes avec des nœuds GPU. Nous vous recommandons d’utiliser W&B Launch pour l’entraînement de grands modèles. Cela évite de surcharger votre instance et donne accès à des ressources de calcul plus adaptées. +
+ ### Ajoutez des fichiers, des répertoires et des références externes à vos Artifacts via les métadonnées +
-7. Lors du suivi des expériences dans Dagster, définissez votre ID de run W&B sur la valeur de votre ID de run Dagster. - Nous vous recommandons de faire les deux : rendre le [Run reprenable](/fr/models/runs/resuming) et définir l’ID de run W&B sur l’ID de run Dagster ou sur la chaîne de votre choix. En suivant cette recommandation, vous vous assurez que vos métriques W&B et vos Artifacts W&B sont stockés dans le même Run W&B lorsque vous entraînez des modèles dans Dagster. +Utilisez l’objet d’intégration `wandb_artifact_configuration` pour ajouter des fichiers, des répertoires ou des références externes (Amazon S3, GCS, HTTP, etc.). Voir l’exemple avancé dans la [section de configuration de l’Artifact](#configuration-1) pour plus d’informations. -Ou définissez l’ID de run W&B sur l’ID de run Dagster. +
+ ### Utilisez un @asset plutôt qu’un @op lorsqu’un Artifact est produit +
+ +Les Artifacts sont des assets. Utilisez un asset lorsque Dagster gère cet asset. Cela offre une meilleure observabilité dans le catalogue d’assets de Dagit. + +
+ ### Utilisez un SourceAsset pour consommer un Artifact créé en dehors de Dagster +
+ +Cela vous permet de tirer parti de l’intégration pour lire des Artifacts créés en dehors de Dagster. Sinon, vous ne pouvez utiliser que les Artifacts créés par l’intégration. + +
+ ### Utilisez W&B Launch pour orchestrer l’entraînement sur des ressources de calcul dédiées pour les grands modèles +
+ +Vous pouvez entraîner de petits modèles dans votre cluster Dagster et exécuter Dagster dans un cluster Kubernetes avec des nœuds GPU. Utilisez W&B Launch pour l’entraînement de grands modèles. Cela évite de surcharger votre instance et donne accès à des ressources de calcul plus adaptées. + +
+ ### Lors du suivi des expériences dans Dagster, définissez votre ID de run W&B sur la valeur de votre ID de run Dagster +
+ +Rendez le [Run reprenable](/fr/models/runs/resuming) et définissez l’ID de run W&B sur l’ID de run Dagster ou sur la chaîne de votre choix. En suivant cette recommandation, vous vous assurez que vos métriques W&B et vos Artifacts W&B sont stockés dans le même Run W&B lorsque vous entraînez des modèles dans Dagster. + +Définissez soit l’ID de run W&B sur l’ID de run Dagster : ```python wandb.init( @@ -1042,7 +1086,7 @@ wandb.init( ) ``` -Ou choisissez votre propre ID de run W&B et renseignez-le dans la configuration de l’IO Manager. +Ou choisissez votre propre ID de run W&B et renseignez-le dans la configuration de l’IO Manager : ```python wandb.init( @@ -1060,10 +1104,16 @@ wandb.init( ) ``` -8. Ne collectez que les données dont vous avez besoin avec get ou get_path pour les W&B Artifacts volumineux. - Par défaut, l’intégration télécharge l’intégralité d’un Artifact. Si vous utilisez des artifacts très volumineux, vous pouvez ne collecter que les fichiers ou objets spécifiques dont vous avez besoin. Cela améliorera la vitesse et l’utilisation des ressources. +
+ ### Ne collectez que les données dont vous avez besoin avec get ou get_path pour les W&B Artifacts volumineux +
+ +Par défaut, l’intégration télécharge l’intégralité d’un Artifact. Si vous utilisez des artifacts volumineux, vous pouvez ne collecter que les fichiers ou objets spécifiques dont vous avez besoin. Cela améliorera la vitesse et l’utilisation des ressources. + +
+ ### Pour les objets Python, adaptez le module de pickling à votre cas d’utilisation. +
-9. Pour les objets Python, adaptez le module de pickling à votre cas d’utilisation. - Par défaut, l’intégration W&B utilise le module standard [pickle](https://docs.python.org/3/library/pickle.html). Mais certains objets ne sont pas compatibles avec celui-ci. Par exemple, les fonctions qui utilisent yield génèrent une erreur si vous essayez de les sérialiser avec pickle. W&B prend en charge d’autres modules de sérialisation basés sur Pickle ([dill](https://github.com/uqfoundation/dill), [cloudpickle](https://github.com/cloudpipe/cloudpickle), [joblib](https://github.com/joblib/joblib)). +Par défaut, l’intégration W&B utilise le module standard [pickle](https://docs.python.org/3/library/pickle.html). Mais certains objets ne sont pas compatibles avec celui-ci. Par exemple, les fonctions qui utilisent yield génèrent une erreur si vous essayez de les sérialiser avec pickle. W&B prend en charge d’autres modules de sérialisation basés sur Pickle ([dill](https://github.com/uqfoundation/dill), [cloudpickle](https://github.com/cloudpipe/cloudpickle), [joblib](https://github.com/joblib/joblib)). -Vous pouvez également utiliser des formats de sérialisation plus avancés comme [ONNX](https://onnx.ai/) ou [PMML](https://en.wikipedia.org/wiki/Predictive_Model_Markup_Language) en renvoyant une chaîne sérialisée ou en créant directement un Artifact. Le bon choix dépend de votre cas d’utilisation ; reportez-vous à la littérature disponible sur ce sujet. +Vous pouvez également utiliser des formats de sérialisation plus avancés comme [ONNX](https://onnx.ai/) ou [PMML](https://en.wikipedia.org/wiki/Predictive_Model_Markup_Language) en renvoyant une chaîne sérialisée ou en créant directement un Artifact. Le bon choix dépend de votre cas d’utilisation ; reportez-vous à la littérature disponible sur ce sujet. \ No newline at end of file diff --git a/fr/models/integrations/databricks.mdx b/fr/models/integrations/databricks.mdx index 9e724573fb..42a7465c61 100644 --- a/fr/models/integrations/databricks.mdx +++ b/fr/models/integrations/databricks.mdx @@ -3,34 +3,36 @@ description: "Intégrez W&B à Databricks pour le suivi des expériences, la jou title: Databricks --- -W&B s’intègre à [Databricks](https://www.databricks.com/) en adaptant l’expérience des notebooks Jupyter de W&B à l’environnement Databricks. +W&B s’intègre à [Databricks](https://www.databricks.com/) en adaptant l’expérience des notebooks Jupyter de W&B à l’environnement Databricks. Cette page explique comment installer et authentifier W&B sur un cluster Databricks pour pouvoir suivre les expériences et consigner des métriques depuis des notebooks exécutés sur Spark.
## Configurer Databricks
-1. Installez wandb sur le cluster +Pour utiliser W&B depuis un notebook Databricks, vous devez installer le package `wandb` sur le cluster et configurer l'authentification afin que vos notebooks puissent enregistrer des données dans W&B. - Accédez à la configuration de votre cluster, sélectionnez votre cluster, puis cliquez sur **Libraries**. Cliquez sur **Install New**, choisissez **PyPI**, puis ajoutez le package `wandb`. +1. Installez `wandb` sur le cluster + + Dans la configuration de votre cluster, choisissez votre cluster, puis cliquez sur **Libraries** > **Install New** > **PyPI**, et ajoutez le package `wandb`. 2. Configurez l'authentification - Pour authentifier votre compte W&B, vous pouvez ajouter un secret Databricks que vos notebooks pourront consulter. + Pour authentifier votre compte W&B, ajoutez un secret Databricks que vos notebooks peuvent interroger au moment de l'exécution. Cela évite d'inscrire votre clé API en dur dans les notebooks. ```bash # installer la CLI Databricks pip install databricks-cli - # Générer un token depuis l'UI Databricks + # Générer un jeton depuis l'interface utilisateur de Databricks databricks configure --token - # Créer un scope avec l'une des deux commandes (selon que les fonctionnalités de sécurité sont activées ou non sur Databricks) : - # avec l'extension de sécurité + # Créer un scope avec l'une des deux commandes (selon que vous avez activé ou non les fonctionnalités de sécurité sur Databricks) : + # avec le module complémentaire de sécurité databricks secrets create-scope --scope wandb - # sans l'extension de sécurité + # sans le module complémentaire de sécurité databricks secrets create-scope --scope wandb --initial-manage-principal users - # Créer une clé API à l'adresse https://wandb.ai/settings + # Créer une clé API sur https://wandb.ai/settings databricks secrets put --scope wandb --key api_key ``` @@ -38,8 +40,10 @@ W&B s’intègre à [Databricks](https://www.databricks.com/) en adaptant l ## Exemples -
- ### Exemple simple +Les exemples suivants montrent comment utiliser le secret précédent pour vous connecter et commencer à journaliser depuis un notebook Databricks. + +
+ ### Exemple de base
```python @@ -53,17 +57,15 @@ with wandb.init() as run: run.log({"foo": 1}) ``` -
### Sweeps
-Configuration requise (temporairement) pour les notebooks qui essaient d’utiliser wandb.sweep() ou wandb.agent() : +Les notebooks qui utilisent `wandb.sweep()` ou `wandb.agent()` doivent définir l’entité et le projet en tant que variables d’environnement : ```python import os -# Ces lignes ne seront plus nécessaires à l'avenir os.environ["WANDB_ENTITY"] = "my-entity" os.environ["WANDB_PROJECT"] = "my-project-that-exists" -``` +``` \ No newline at end of file diff --git a/fr/models/integrations/deepchecks.mdx b/fr/models/integrations/deepchecks.mdx index 98f4f6a07b..844b175959 100644 --- a/fr/models/integrations/deepchecks.mdx +++ b/fr/models/integrations/deepchecks.mdx @@ -7,59 +7,57 @@ import { ColabLink } from '/snippets/fr/_includes/colab-link.mdx'; -DeepChecks vous aide à valider vos modèles de machine learning et vos données, par exemple en vérifiant l’intégrité de vos données, en examinant leurs distributions, en validant les découpages des données, en évaluant votre modèle et en comparant différents modèles, le tout avec un minimum d’effort. +DeepChecks vous aide à valider vos modèles de machine learning et vos données avec un minimum d’effort. Vous pouvez vérifier l’intégrité de vos données, examiner leurs distributions, valider les découpages des données, évaluer votre modèle et comparer différents modèles. Cette page montre comment utiliser l’intégration DeepChecks avec W&B afin de consigner les résultats de validation et les suites de tests avec vos expériences. -[En savoir plus sur DeepChecks et l’intégration à wandb ->](https://docs.deepchecks.com/stable/general/usage/exporting_results/auto_examples/plot_exports_output_to_wandb.html) +Pour plus d'informations, voir le [guide d’intégration DeepChecks W&B](https://docs.deepchecks.com/stable/general/usage/exporting_results/auto_examples/plot_exports_output_to_wandb.html). - -
+
## Premiers pas
-Pour utiliser DeepChecks avec W&B, vous devez d’abord créer un [compte W&B](https://wandb.ai/site). Grâce à l’intégration W&B dans DeepChecks, vous pouvez démarrer rapidement comme suit : +Pour utiliser DeepChecks avec W&B, commencez par vous inscrire pour créer un [compte W&B](https://wandb.ai/site). Grâce à l’intégration W&B dans DeepChecks, vous pouvez commencer par exécuter une seule vérification et téléverser le résultat vers W&B : ```python import wandb wandb.login() -# importez votre vérification depuis deepchecks +# importer votre vérification depuis deepchecks from deepchecks.checks import ModelErrorAnalysis -# exécutez votre vérification +# exécuter votre vérification result = ModelErrorAnalysis() -# envoyez ce résultat à wandb +# téléverser ce résultat vers wandb result.to_wandb() ``` -Vous pouvez également journaliser l’intégralité d’une suite de tests DeepChecks dans W&B. +En plus de journaliser des vérifications individuelles, vous pouvez journaliser une suite de tests DeepChecks complète dans W&B : ```python import wandb wandb.login() -# importer vos tests full_suite depuis deepchecks +# importez vos tests full_suite depuis deepchecks from deepchecks.suites import full_suite -# créer et exécuter une suite de tests DeepChecks +# créez et exécutez une suite de tests DeepChecks suite_result = full_suite().run(...) -# envoyer ces résultats à wandb -# vous pouvez passer ici toutes les configurations et arguments wandb.init dont vous avez besoin +# téléversez ces résultats vers wandb +# vous pouvez ici transmettre toutes les configurations et arguments wandb.init dont vous avez besoin suite_result.to_wandb(project="my-suite-project", config={"suite-name": "full-suite"}) ``` -
## Exemple
-[Ce Report](https://wandb.ai/cayush/deepchecks/reports/Validate-your-Data-and-Models-with-Deepchecks-and-W-B--VmlldzoxNjY0ODc5) illustre la puissance de DeepChecks et de W&B. +Pour voir à quoi ressemble l’intégration en pratique, explorez le [W&B Report Validez vos données et vos modèles avec Deepchecks](https://wandb.ai/cayush/deepchecks/reports/Validate-your-Data-and-Models-with-Deepchecks-and-W-B--VmlldzoxNjY0ODc5), qui montre comment utiliser DeepChecks et W&B ensemble. Résultats de validation des données avec DeepChecks -Des questions ou des problèmes avec cette intégration W&B ? Ouvrez une issue dans le [dépôt GitHub de DeepChecks](https://github.com/deepchecks/deepchecks), et nous vous répondrons. \ No newline at end of file +Si vous avez des questions ou des problèmes avec cette intégration W&B, ouvrez une issue dans le [dépôt GitHub de DeepChecks](https://github.com/deepchecks/deepchecks) et nous vous répondrons. \ No newline at end of file diff --git a/fr/models/integrations/deepchem.mdx b/fr/models/integrations/deepchem.mdx index b737529342..8d5f600bcc 100644 --- a/fr/models/integrations/deepchem.mdx +++ b/fr/models/integrations/deepchem.mdx @@ -5,7 +5,9 @@ title: DeepChem import ApiKeyCreateStreamlined from "/snippets/fr/_includes/api-key-create-streamlined.mdx"; -La [bibliothèque DeepChem](https://github.com/deepchem/deepchem) fournit des outils open source qui démocratisent l’usage du deep learning dans la découverte de médicaments, la science des matériaux, la chimie et la biologie. Cette intégration W&B ajoute un suivi des expériences simple et facile à utiliser, ainsi que la gestion des points de contrôle du modèle pendant l’entraînement des modèles avec DeepChem. +La [bibliothèque DeepChem](https://github.com/deepchem/deepchem) fournit des outils open source qui démocratisent l’usage du deep learning dans la découverte de médicaments, la science des matériaux, la chimie et la biologie. Cette intégration W&B ajoute le suivi des expériences et la gestion des points de contrôle du modèle pendant l’entraînement de modèles avec DeepChem. + +Utilisez cette page pour ajouter la journalisation W&B à votre flux de travail d’entraînement avec DeepChem afin de pouvoir suivre la perte d’entraînement, les métriques d’évaluation et les points de contrôle du modèle d’une expérience à l’autre. Si vous entraînez déjà des modèles avec DeepChem, vous pouvez ajouter le suivi des expériences avec un minimum de modifications du code.
## Journalisation avec DeepChem en 3 lignes de code @@ -17,6 +19,8 @@ model = TorchModel(…, wandb_logger=logger) model.fit(…) ``` +Le fait de passer une instance `WandbLogger` à un modèle DeepChem active la journalisation W&B pour le run d'entraînement, de sorte que les métriques produites pendant `fit` soient automatiquement transmises à votre projet W&B. + Analyse moléculaire avec DeepChem @@ -25,14 +29,17 @@ model.fit(…) ## Rapport et Google Colab
-Consultez l’article [W&B with DeepChem: Molecular Graph Convolutional Networks](https://wandb.ai/kshen/deepchem_graphconv/reports/Using-W-B-with-DeepChem-Molecular-Graph-Convolutional-Networks--Vmlldzo4MzU5MDc?galleryTag=) pour voir des exemples de graphiques générés à l’aide de l’intégration DeepChem de W&B. +Les ressources suivantes montrent l’intégration en pratique avant que vous ne l’intégriez à votre propre code : -Pour passer directement à du code opérationnel, consultez ce [Google Colab](https://colab.research.google.com/github/wandb/examples/blob/master/colabs/deepchem/W%26B_x_DeepChem.ipynb). +* Consultez l’article [W&B with DeepChem: Molecular Graph Convolutional Networks](https://wandb.ai/kshen/deepchem_graphconv/reports/Using-W-B-with-DeepChem-Molecular-Graph-Convolutional-Networks--Vmlldzo4MzU5MDc?galleryTag=) pour voir des exemples de graphiques générés à l’aide de l’intégration DeepChem de W&B. +* Pour passer directement à du code opérationnel, consultez ce [Google Colab](https://colab.research.google.com/github/wandb/examples/blob/master/colabs/deepchem/W%26B_x_DeepChem.ipynb).
## Suivre les expériences
+Le reste de cette page explique comment configurer une clé API, installer la bibliothèque `wandb` et activer la journalisation pour un `TorchModel` ou un `KerasModel`. + Configurez W&B pour les modèles DeepChem de type [KerasModel](https://deepchem.readthedocs.io/en/latest/api_reference/models.html#keras-models) ou [TorchModel](https://deepchem.readthedocs.io/en/latest/api_reference/models.html#pytorch-models).
@@ -43,6 +50,8 @@ Une clé API authentifie votre machine auprès de W&B. Vous pouvez générer +Pour trouver votre clé API dans W&B App : + 1. Cliquez sur l’icône de votre profil dans l’angle supérieur droit. 2. Sélectionnez **Paramètres utilisateur**, puis faites défiler jusqu’à la section **Clés API**. @@ -54,7 +63,7 @@ Pour installer la bibliothèque `wandb` localement et vous connecter : - 1. Définissez la [variable d'environnement](/fr/models/track/environment-variables/) `WANDB_API_KEY` avec votre clé API. + 1. Définissez la [variable d'environnement](/fr/models/track/environment-variables/) `WANDB_API_KEY` avec votre clé API. Remplacez les valeurs entre `<>` par les vôtres : ```bash export WANDB_API_KEY= @@ -91,10 +100,12 @@ Pour installer la bibliothèque `wandb` localement et vous connecter :
- ### Consignez vos données d'entraînement et d'évaluation dans W&B + ### Journalisez vos données d’entraînement et d’évaluation dans W&B
-La perte d'entraînement et les métriques d'évaluation peuvent être automatiquement consignées dans W&B. Vous pouvez activer l'évaluation facultative à l'aide du [ValidationCallback](https://github.com/deepchem/deepchem/blob/master/deepchem/models/callbacks.py) de DeepChem ; `WandbLogger` détectera alors le callback `ValidationCallback` et consignera les métriques générées. +Une fois `wandb` installé et authentifié, vous pouvez désormais joindre un `WandbLogger` à votre modèle DeepChem afin que les données d’entraînement et d’évaluation soient envoyées à W&B. + +La perte d’entraînement et les métriques d’évaluation sont automatiquement journalisées dans W&B. Pour activer l’évaluation facultative, utilisez le [`ValidationCallback`](https://github.com/deepchem/deepchem/blob/master/deepchem/models/callbacks.py) de DeepChem. Le `WandbLogger` détecte le `ValidationCallback` et journalise les métriques qu’il produit. @@ -118,4 +129,6 @@ La perte d'entraînement et les métriques d'évaluation peuvent être a logger.finish() ``` - \ No newline at end of file + + +Une fois `model.fit` exécuté, la perte d’entraînement et toutes les métriques d’évaluation émises par le `ValidationCallback` apparaissent dans votre projet W&B, sous le run créé par `WandbLogger`. \ No newline at end of file diff --git a/fr/models/integrations/diffusers.mdx b/fr/models/integrations/diffusers.mdx index 758c0cb468..2d25858fdf 100644 --- a/fr/models/integrations/diffusers.mdx +++ b/fr/models/integrations/diffusers.mdx @@ -7,13 +7,13 @@ import { ColabLink } from '/snippets/fr/_includes/colab-link.mdx'; -[Hugging Face Diffusers](https://huggingface.co/docs/diffusers/index) est la bibliothèque de référence pour les modèles de diffusion préentraînés les plus avancés, permettant de générer des images, de l’Audio et même des structures moléculaires 3D. L’intégration W&B apporte un suivi des expériences riche et flexible, la visualisation des contenus multimédias, l’architecture des pipelines et la gestion de la configuration dans des tableaux de bord centralisés interactifs, sans rien sacrifier à cette simplicité d’utilisation. +[Hugging Face Diffusers](https://huggingface.co/docs/diffusers/index) est une bibliothèque de modèles de diffusion préentraînés permettant de générer des images, de l’Audio et des structures moléculaires 3D. L’intégration W&B apporte le suivi des expériences, la visualisation des contenus multimédias, le suivi de l’architecture des pipelines et la gestion de la configuration dans des tableaux de bord centralisés interactifs. -
- ## Une journalisation avancée en seulement deux lignes +
+ ## Enregistrez les expériences en deux lignes
-Consignez tous les prompts, les prompts négatifs, les médias générés et les configurations liés à votre expérience en ajoutant simplement 2 lignes de code. Voici les 2 lignes de code pour commencer la journalisation : +Pour enregistrer tous les prompts, les prompts négatifs, les médias générés et les configurations associées à votre expérience, ajoutez les deux lignes de code suivantes : ```python # importer la fonction autolog @@ -23,19 +23,19 @@ from wandb.integration.diffusers import autolog autolog(init=dict(project="diffusers_logging")) ``` - - Enregistrement des résultats de l’expérience + + Journalisation des résultats de l'expérience
- ## Pour commencer + ## Premiers pas
1. Installez `diffusers`, `transformers`, `accelerate` et `wandb`. * Ligne de commande : - ```shell + ```bash pip install --upgrade diffusers transformers accelerate wandb ``` @@ -45,30 +45,28 @@ autolog(init=dict(project="diffusers_logging")) !pip install --upgrade diffusers transformers accelerate wandb ``` -2. Utilisez `autolog` pour initialiser un run W&B et suivre automatiquement les entrées et les sorties de [tous les appels de pipeline pris en charge](https://github.com/wandb/wandb/blob/main/wandb/integration/diffusers/autologger.py#L12-L72). - - Vous pouvez appeler la fonction `autolog()` avec le paramètre `init`, qui accepte un dictionnaire de paramètres requis par [`wandb.init()`](/fr/models/ref/python/functions/init). - - Lorsque vous appelez `autolog()`, un run W&B est initialisé et les entrées ainsi que les sorties de [tous les appels de pipeline pris en charge](https://github.com/wandb/wandb/blob/main/wandb/integration/diffusers/autologger.py#L12-L72) sont automatiquement suivies. +2. Appelez `autolog()` avec le paramètre `init`, qui accepte un dictionnaire de paramètres requis par [`wandb.init()`](/fr/models/ref/python/functions/init). `autolog()` initialise un run W&B et suit automatiquement les entrées et sorties de [tous les appels de pipeline pris en charge](https://github.com/wandb/wandb/blob/main/wandb/integration/diffusers/autologger.py#L12-L72) : - * Chaque appel de pipeline est suivi dans son propre [tableau](/fr/models/tables/) dans le Workspace, et les configurations associées à cet appel sont ajoutées à la liste des flux de travail dans la configuration de ce run. + * Chaque appel de pipeline est suivi dans son propre [tableau](/fr/models/tables/) de l’espace de travail, et les configurations associées à cet appel de pipeline sont ajoutées à la liste des flux de travail dans la configuration de ce run. * Les prompts, les prompts négatifs et les médias générés sont enregistrés dans un [`wandb.Table`](/fr/models/tables/). - * Toutes les autres configurations associées à l’expérience, y compris la seed et l’architecture du pipeline, sont stockées dans la section de configuration du run. - * Les médias générés pour chaque appel de pipeline sont également enregistrés dans les [panneaux multimédias](/fr/models/track/log/media/) du run. + * Toutes les autres configurations associées à l’expérience, y compris la graine aléatoire et l’architecture du pipeline, sont stockées dans la section de configuration du run. + * Les médias générés pour chaque appel de pipeline sont également enregistrés dans les [volets multimédia](/fr/models/track/log/media/) du run. - Vous trouverez une [liste des appels de pipeline pris en charge](https://github.com/wandb/wandb/blob/main/wandb/integration/diffusers/autologger.py#L12-L72). Si vous souhaitez demander une nouvelle fonctionnalité pour cette intégration ou signaler un bug associé, ouvrez une issue sur la [page GitHub issues de W&B](https://github.com/wandb/wandb/issues). + Vous trouverez une [liste des appels de pipeline pris en charge](https://github.com/wandb/wandb/blob/main/wandb/integration/diffusers/autologger.py#L12-L72). Pour demander une nouvelle fonctionnalité pour cette intégration ou signaler un bug, ouvrez une issue sur la [page des issues GitHub de W&B](https://github.com/wandb/wandb/issues).
## Exemples
-
- ### Autologging +Les exemples suivants illustrent l’utilisation de `autolog` dans des flux de travail de diffusion courants, afin que vous puissiez les adapter à vos propres pipelines. + +
+ ### Exemple d’autolog
-Voici un bref exemple de bout en bout illustrant autolog en action : +Voici un exemple complet de `autolog` : @@ -87,7 +85,7 @@ Voici un bref exemple de bout en bout illustrant autolog en action : "stabilityai/stable-diffusion-2-1", torch_dtype=torch.float16 ).to("cuda") - # Définir les prompts, les prompts négatifs et la graine + # Définir les prompts, les prompts négatifs et le seed. prompt = ["a photograph of an astronaut riding a horse", "a photograph of a dragon"] negative_prompt = ["ugly, deformed", "ugly, deformed"] generator = torch.Generator(device="cpu").manual_seed(10) @@ -122,7 +120,7 @@ Voici un bref exemple de bout en bout illustrant autolog en action : "stabilityai/stable-diffusion-2-1", torch_dtype=torch.float16 ).to("cuda") - # Définir les prompts, les prompts négatifs et la graine + # Définir les prompts, les prompts négatifs et le seed. prompt = ["a photograph of an astronaut riding a horse", "a photograph of a dragon"] negative_prompt = ["ugly, deformed", "ugly, deformed"] generator = torch.Generator(device="cpu").manual_seed(10) @@ -141,42 +139,44 @@ Voici un bref exemple de bout en bout illustrant autolog en action : +Les images suivantes montrent ce qui est consigné dans W&B : + * Les résultats d’une seule expérience : - Journalisation des résultats de l’expérience + journalisation des résultats de l'expérience * Les résultats de plusieurs expériences : - Journalisation des résultats de l’expérience + journalisation des résultats de l'expérience * La configuration d’une expérience : - Journalisation de la configuration de l’expérience + journalisation de la configuration de l'expérience - Vous devez appeler explicitement [`wandb.Run.finish()`](/fr/models/ref/python/functions/finish) lorsque vous exécutez le code dans un environnement de notebook IPython après avoir appelé le pipeline. Cela n’est pas nécessaire lors de l’exécution de scripts Python. + Vous devez appeler explicitement [`wandb.Run.finish()`](/fr/models/ref/python/functions/finish) lorsque vous exécutez le code dans un environnement de notebook IPython après l’appel au pipeline. Ce n’est pas nécessaire lorsque vous exécutez des scripts Python. -
+
### Suivi des flux de travail à plusieurs pipelines
-Cette section illustre l’autolog dans un flux de travail type [Stable Diffusion XL + Refiner](https://huggingface.co/docs/diffusers/using-diffusers/sdxl#base-to-refiner-model), où les variables latentes générées par [`StableDiffusionXLPipeline`](https://huggingface.co/docs/diffusers/api/pipelines/stable_diffusion/stable_diffusion_xl) sont affinées par le refiner correspondant. +L’exemple suivant illustre `autolog` dans un flux de travail type [Stable Diffusion XL + Refiner](https://huggingface.co/docs/diffusers/using-diffusers/sdxl#base-to-refiner-model), où le refiner affine les variables latentes générées par le [`StableDiffusionXLPipeline`](https://huggingface.co/docs/diffusers/api/pipelines/stable_diffusion/stable_diffusion_xl). - + ```python import torch from diffusers import StableDiffusionXLImg2ImgPipeline, StableDiffusionXLPipeline from wandb.integration.diffusers import autolog - # initialiser le pipeline de base SDXL + # Initialiser le pipeline de base SDXL base_pipeline = StableDiffusionXLPipeline.from_pretrained( "stabilityai/stable-diffusion-xl-base-1.0", torch_dtype=torch.float16, @@ -185,7 +185,7 @@ Cette section illustre l’autolog dans un flux de travail type [Stable Diffusio ) base_pipeline.enable_model_cpu_offload() - # initialiser le pipeline de raffinement SDXL + # Initialiser le pipeline de raffinement SDXL refiner_pipeline = StableDiffusionXLImg2ImgPipeline.from_pretrained( "stabilityai/stable-diffusion-xl-refiner-1.0", text_encoder_2=base_pipeline.text_encoder_2, @@ -207,8 +207,8 @@ Cette section illustre l’autolog dans un flux de travail type [Stable Diffusio # Appeler WandB Autolog pour Diffusers. Cela enregistrera automatiquement # les prompts, les images générées, l'architecture du pipeline et toutes - # les configurations d'expérience associées dans W&B, facilitant ainsi la - # reproduction, le partage et l'analyse de vos expériences de génération d'images. + # les configurations d'expérience associées dans W&B, facilitant ainsi + # la reproduction, le partage et l'analyse de vos expériences de génération d'images. autolog(init=dict(project="sdxl")) # Appeler le pipeline de base pour générer les latents @@ -239,7 +239,7 @@ Cette section illustre l’autolog dans un flux de travail type [Stable Diffusio run = wandb.init() - # initialiser le pipeline de base SDXL + # Initialiser le pipeline de base SDXL base_pipeline = StableDiffusionXLPipeline.from_pretrained( "stabilityai/stable-diffusion-xl-base-1.0", torch_dtype=torch.float16, @@ -248,7 +248,7 @@ Cette section illustre l’autolog dans un flux de travail type [Stable Diffusio ) base_pipeline.enable_model_cpu_offload() - # initialiser le pipeline de raffinement SDXL + # Initialiser le pipeline de raffinement SDXL refiner_pipeline = StableDiffusionXLImg2ImgPipeline.from_pretrained( "stabilityai/stable-diffusion-xl-refiner-1.0", text_encoder_2=base_pipeline.text_encoder_2, @@ -270,8 +270,8 @@ Cette section illustre l’autolog dans un flux de travail type [Stable Diffusio # Appeler WandB Autolog pour Diffusers. Cela enregistrera automatiquement # les prompts, les images générées, l'architecture du pipeline et toutes - # les configurations d'expérience associées dans W&B, facilitant ainsi la - # reproduction, le partage et l'analyse de vos expériences de génération d'images. + # les configurations d'expérience associées dans W&B, facilitant ainsi + # la reproduction, le partage et l'analyse de vos expériences de génération d'images. autolog(init=dict(project="sdxl")) # Appeler le pipeline de base pour générer les latents @@ -296,10 +296,11 @@ Cette section illustre l’autolog dans un flux de travail type [Stable Diffusio -* Exemple d'expérience Stable Diffusion XL + Refiner : - - suivi des expériences Stable Diffusion XL - +L’image suivante montre un exemple d’expérience Stable Diffusion XL + Refiner : + + + suivi des expériences Stable Diffusion XL +
## Autres ressources diff --git a/fr/models/integrations/docker.mdx b/fr/models/integrations/docker.mdx index 53228ca0fe..30a7ee2f12 100644 --- a/fr/models/integrations/docker.mdx +++ b/fr/models/integrations/docker.mdx @@ -7,28 +7,32 @@ title: Docker ## Intégration Docker
-W&B peut stocker une référence vers l’image Docker dans laquelle votre code a été exécuté, ce qui vous permet de restaurer une expérience précédente dans l’environnement exact où elle s’est exécutée. La bibliothèque wandb recherche la variable d’environnement **WANDB_DOCKER** pour enregistrer cet état. Nous fournissons quelques utilitaires qui définissent automatiquement cet état. +W&B peut stocker un pointeur vers l’image Docker utilisée pour exécuter votre code, ce qui vous permet de restaurer une expérience précédente dans l’environnement exact dans lequel elle a été exécutée. Le SDK Python W&B (`wandb`) recherche la variable d’environnement `WANDB_DOCKER` pour enregistrer cet état. W&B fournit quelques utilitaires qui définissent automatiquement cet état. + +Les sections suivantes décrivent comment définir la variable d’environnement `WANDB_DOCKER` dans différents environnements, du développement local à l’entraînement sur Kubernetes.
### Développement local
-`wandb docker` est une commande qui lance un conteneur Docker, transmet les variables d'environnement wandb, monte votre code et s'assure que wandb est installé. Par défaut, la commande utilise une image Docker avec TensorFlow, PyTorch, Keras et Jupyter installés. Vous pouvez utiliser la même commande pour lancer votre propre image Docker : `wandb docker my/image:latest`. La commande monte le répertoire courant dans le répertoire "/app" du conteneur. Vous pouvez modifier ce comportement avec l'option "--dir". +`wandb docker` est une commande qui lance un conteneur Docker, transmet les variables d’environnement wandb, monte votre code et s’assure que wandb est installé. Par défaut, la commande utilise une image Docker avec TensorFlow, PyTorch, Keras et Jupyter installés. Vous pouvez utiliser la même commande pour lancer votre propre image Docker : `wandb docker my/image:latest`. La commande monte le répertoire courant dans le répertoire `/app` du conteneur. Vous pouvez modifier ce comportement avec l’option `--dir`.
### Production
-La commande `wandb docker-run` est destinée aux charges de travail de production. Elle est conçue pour remplacer directement `nvidia-docker`. Il s'agit d'un simple wrapper autour de la commande `docker run` qui ajoute vos identifiants et la variable d'environnement **WANDB_DOCKER** à l'appel. Si vous ne transmettez pas l'option `--runtime` et que `nvidia-docker` est disponible sur la machine, cela garantit également que le runtime est défini sur `nvidia`. +La commande `wandb docker-run` est destinée aux charges de travail de production. Elle est conçue pour remplacer directement `nvidia-docker` en encapsulant la commande `docker run` et en ajoutant vos identifiants et la variable d'environnement `WANDB_DOCKER` à l'appel. Si vous ne transmettez pas l'option `--runtime` et que `nvidia-docker` est disponible sur la machine, cela garantit également que le runtime est défini sur `nvidia`.
### Kubernetes
-Si vous exécutez vos charges de travail d'entraînement dans Kubernetes et que l'API k8s est exposée à votre pod (ce qui est le cas par défaut), wandb interroge l'API pour récupérer le digest de l'image Docker et définit automatiquement la variable d'environnement **WANDB_DOCKER**. +Si vous exécutez vos charges de travail d'entraînement dans Kubernetes et que l'API Kubernetes est exposée à votre pod (ce qui est le cas par défaut), W&B interroge l'API pour récupérer le digest de l'image Docker et définit automatiquement la variable d'environnement `WANDB_DOCKER`. -
- ## Restauration +
+ ## Restaurer l’environnement d’entraînement
-Si un run a été instrumenté avec la variable d’environnement **WANDB_DOCKER**, l’exécution de `wandb restore username/project:run_id` créera une nouvelle branche pour restaurer votre code, puis lancera l’image Docker exacte utilisée pour l’entraînement, préremplie avec la commande originale. \ No newline at end of file +Une fois la variable d’environnement `WANDB_DOCKER` définie pendant un run, vous pouvez l’utiliser pour reproduire ultérieurement l’environnement d’entraînement d’origine. + +Si un run a été instrumenté avec la variable d’environnement `WANDB_DOCKER`, l’exécution de `wandb restore username/project:run_id` extrait une nouvelle branche qui restaure votre code, puis lance l’image Docker exacte utilisée pour l’entraînement, préremplie avec la commande d’origine. \ No newline at end of file diff --git a/fr/models/integrations/dspy.mdx b/fr/models/integrations/dspy.mdx index 352a28a878..dd911fac35 100644 --- a/fr/models/integrations/dspy.mdx +++ b/fr/models/integrations/dspy.mdx @@ -3,7 +3,9 @@ description: "Suivez et optimisez les programmes DSPy avec W&B pour consigner le title: DSPy --- -Utilisez W&B avec DSPy pour suivre et optimiser vos programmes pour modèles de langage. W&B complète l’[intégration DSPy de Weave](/fr/weave/guides/integrations/dspy) en fournissant : +Ce guide explique comment utiliser W&B avec DSPy pour suivre et optimiser vos programmes pour modèles de langage, afin de surveiller les métriques d’évaluation, d’examiner l’évolution des signatures de programme pendant l’optimisation et de versionner les programmes obtenus sous forme d’artefacts reproductibles. Utilisez-le si vous souhaitez disposer d’un suivi des expériences et d’une observabilité pour vos modules compilés. + +W&B complète l’[intégration DSPy de Weave](/fr/weave/guides/integrations/dspy) en fournissant : * Le suivi des métriques d’évaluation dans le temps * W&B Tables pour suivre l’évolution des signatures de programme @@ -36,7 +38,7 @@ Installez les bibliothèques requises et authentifiez-vous avec W&B : pip install wandb weave dspy ``` - 2. Définissez la variable d’[environnement](/fr/models/track/environment-variables/) `WANDB_API_KEY`, puis connectez-vous : + 2. Définissez la variable d’[environnement](/fr/models/track/environment-variables/) `WANDB_API_KEY`, puis connectez-vous. Remplacez `` par votre clé API W&B : ```bash export WANDB_API_KEY= @@ -70,13 +72,15 @@ Installez les bibliothèques requises et authentifiez-vous avec W&B : -Vous découvrez W&B ? Voir notre [guide de démarrage rapide](/fr/models/quickstart/). +Vous découvrez W&B ? Voir le [Démarrage rapide](/fr/models/quickstart/). + +Une fois les bibliothèques installées et l’authentification en place, vous êtes prêt à instrumenter une exécution d’optimisation DSPy.
- ## Suivez l’optimisation du programme (expérimental) + ## Suivre l’optimisation du programme (expérimental)
-Pour les optimiseurs DSPy qui utilisent `dspy.Evaluate` (comme MIPROv2), utilisez `WandbDSPyCallback` pour journaliser les métriques d’évaluation au fil du temps et suivre l’évolution de la signature du programme dans les W&B Tables. +Pour les optimiseurs DSPy qui utilisent `dspy.Evaluate` (comme MIPROv2), utilisez `WandbDSPyCallback` pour consigner les métriques d’évaluation au fil du temps et suivre l’évolution des signatures du programme dans W&B Tables. L’ajout du callback vous permet d’observer comment le score de l’optimiseur évolue et comment les prompts et les signatures du programme changent au fil des itérations. ```python import dspy @@ -86,7 +90,7 @@ import weave import wandb from wandb.integration.dspy import WandbDSPyCallback -# Initialiser W&B (importer weave est suffisant ; pas besoin d'appeler weave.init explicitement) +# Initialiser W&B (importer weave suffit ; inutile d'appeler weave.init explicitement) project_name = "dspy-optimization" with wandb.init(project=project_name) as run: # Ajouter le callback W&B à DSPy @@ -99,11 +103,11 @@ with wandb.init(project=project_name) as run: student_lm = dspy.LM('openai/gpt-4o-mini', max_tokens=2000) dspy.configure(lm=student_lm) - # Charger le jeu de données et définir le programme + # Charger le dataset et définir le programme dataset = MATH(subset='algebra') program = dspy.ChainOfThought("question -> answer") - # Configurer et exécuter l'optimiseur + # Configurer et lancer l'optimizer optimizer = dspy.MIPROv2( metric=dataset.metric, auto="light", @@ -120,26 +124,26 @@ with wandb.init(project=project_name) as run: ) ``` -Après avoir exécuté ce code, vous obtenez à la fois une URL de run W&B et une URL Weave. W&B affiche les métriques d'évaluation au fil du temps, ainsi que des Tables montrant l'évolution des signatures du programme. L'onglet **Aperçu** du run inclut des liens vers les traces Weave pour une inspection détaillée. +Après avoir exécuté ce code, vous recevez à la fois une URL de Run W&B et une URL Weave. W&B affiche les métriques d’évaluation au fil du temps, ainsi que des tableaux montrant l’évolution des signatures du programme. L’onglet **Aperçu** du run inclut des liens vers les traces Weave pour une inspection détaillée. -Si aucun objet `run` n'est passé à `WandbDSPyCallback`, l'objet global `run` est utilisé. +Si vous ne transmettez pas d’objet `run` à `WandbDSPyCallback`, le callback utilise l’objet `run` global. - run d’optimisation DSPy dans W&B + Run d’optimisation DSPy dans W&B -Pour des informations complètes sur le tracing dans Weave, l'évaluation et l'optimisation avec DSPy, voir le [guide d'intégration Weave DSPy](/fr/weave/guides/integrations/dspy). +Pour plus de détails sur le traçage Weave, l’évaluation et l’optimisation avec DSPy, voir le [guide d’intégration DSPy de Weave](/fr/weave/guides/integrations/dspy).
- ## Enregistrez les prédictions dans W&B Tables + ## Journaliser les prédictions dans W&B Tables
-Activez un logging détaillé des prédictions pour inspecter des exemples individuels pendant l’optimisation. Le callback crée une W&B Tables pour chaque étape d’évaluation, ce qui peut vous aider à analyser des réussites et des échecs précis. +En plus des métriques agrégées, vous pouvez activer la journalisation détaillée des prédictions pour examiner des exemples individuels pendant l’optimisation. Le callback crée un tableau W&B à chaque étape d’évaluation, ce qui vous aide à analyser des réussites et des échecs spécifiques. ```python from wandb.integration.dspy import WandbDSPyCallback -# Activer la journalisation des prédictions (activée par défaut) +# Activer la journalisation des prédictions (activé par défaut) callback = WandbDSPyCallback(log_results=True) dspy.settings.callbacks.append(callback) @@ -157,7 +161,7 @@ optimized_program = optimizer.compile(program, trainset=train_data) Après l'optimisation, retrouvez vos données de prédiction dans W&B : 1. Accédez à la page **Aperçu** de votre run. -2. Recherchez les panneaux de tableau nommés selon un format comme `predictions_0`, `predictions_1`, etc. +2. Recherchez les panneaux de tableau nommés selon un format comme `predictions_0` ou `predictions_1`. 3. Filtrez sur `is_correct` pour analyser les échecs. 4. Comparez les tableaux entre les runs dans l’espace de travail du projet. @@ -173,7 +177,7 @@ Pour en savoir plus, consultez le [guide W&B Tables](/fr/models/tables/visua ## Enregistrer et versionner des programmes DSPy
-Pour reproduire et versionner vos meilleurs programmes DSpy, enregistrez-les sous forme de W&B Artifacts. Choisissez entre enregistrer l’intégralité du programme ou seulement son état. +Une fois que vous avez identifié un programme optimisé très performant, enregistrez-le comme artefact W&B afin de pouvoir reproduire les résultats et suivre les versions au fil du temps. Choisissez entre l’enregistrement du programme complet ou du seul état, selon que vous avez besoin de l’architecture complète ou d’un point de contrôle plus léger. ```python from wandb.integration.dspy import WandbDSPyCallback @@ -196,10 +200,10 @@ callback.log_best_model(optimized_program, save_program=False, filetype="json") # 3. État uniquement en pickle - préserve les objets Python callback.log_best_model(optimized_program, save_program=False, filetype="pkl") -# Ajouter des alias personnalisés pour la gestion des versions +# Ajouter des aliases personnalisés pour la gestion des versions callback.log_best_model( optimized_program, save_program=True, aliases=["best", "production", "v2.0"] ) -``` +``` \ No newline at end of file diff --git a/fr/models/integrations/farama-gymnasium.mdx b/fr/models/integrations/farama-gymnasium.mdx index f50a0deab6..6842c4c024 100644 --- a/fr/models/integrations/farama-gymnasium.mdx +++ b/fr/models/integrations/farama-gymnasium.mdx @@ -1,13 +1,13 @@ --- -description: "Intégrez W&B à Farama Gymnasium pour suivre les expériences d'apprentissage par renforcement et enregistrer des vidéos d'épisode." +description: "Intégrez W&B à Farama Gymnasium pour suivre les expériences d'apprentissage par renforcement et enregistrer les vidéos d'épisodes." title: Farama Gymnasium --- -Si vous utilisez [Farama Gymnasium](https://gymnasium.farama.org/#), nous enregistrerons automatiquement les vidéos de votre environnement générées par `gymnasium.wrappers.Monitor`. Il vous suffit de définir l'argument mot-clé `monitor_gym` de [`wandb.init()`](/fr/models/ref/python/functions/init) sur `True`. +Si vous utilisez [Farama Gymnasium](https://gymnasium.farama.org/#), W&B enregistre automatiquement les vidéos de votre environnement générées par `gymnasium.wrappers.Monitor`. Pour activer la journalisation vidéo, définissez l'argument nommé `monitor_gym` de [`wandb.init()`](/fr/models/ref/python/functions/init) sur `True`. -Notre intégration à Gymnasium est très légère. Nous [regardons simplement le nom du fichier vidéo](https://github.com/wandb/wandb/blob/c5fe3d56b155655980611d32ef09df35cd336872/wandb/integration/gym/__init__.py#LL69C67-L69C67) enregistré depuis `gymnasium` et l'utilisons comme nom, ou revenons à `"videos"` si aucune correspondance n'est trouvée. Si vous souhaitez avoir plus de contrôle, vous pouvez toujours [enregistrer une vidéo](/fr/models/track/log/media/) manuellement. +L'intégration Gymnasium est légère. W&B [lit le nom du fichier vidéo](https://github.com/wandb/wandb/blob/c5fe3d56b155655980611d32ef09df35cd336872/wandb/integration/gym/__init__.py#LL69C67-L69C67) enregistré par `gymnasium` et réutilise ce nom. Si aucune correspondance n'est trouvée, l'intégration utilise `"videos"` par défaut. Pour plus de contrôle, vous pouvez [enregistrer manuellement une vidéo](/fr/models/track/log/media/). -Consultez ce [rapport](https://wandb.ai/raph-test/cleanrltest/reports/Mario-Bros-but-with-AI-Gymnasium-and-CleanRL---Vmlldzo0NTcxNTcw) pour en savoir plus sur comment utiliser Gymnasium avec la bibliothèque CleanRL. +Pour en savoir plus sur l'utilisation de Gymnasium avec la bibliothèque CleanRL, consultez le rapport [Mario Bros, but with AI: Gymnasium and CleanRL](https://wandb.ai/raph-test/cleanrltest/reports/Mario-Bros-but-with-AI-Gymnasium-and-CleanRL---Vmlldzo0NTcxNTcw). Environnement RL Gymnasium diff --git a/fr/models/integrations/fastai.mdx b/fr/models/integrations/fastai.mdx index 5aef3a26ef..2c580d7472 100644 --- a/fr/models/integrations/fastai.mdx +++ b/fr/models/integrations/fastai.mdx @@ -5,7 +5,7 @@ description: "Intégrez W&B à fastai à l’aide du WandbCallback pour suivre l import ApiKeyCreateStreamlined from "/snippets/fr/_includes/api-key-create-streamlined.mdx"; -Vous pouvez intégrer **fastai** à W&B à l’aide de la classe `WandbCallback`. Consultez cette [documentation interactive avec exemples](https://app.wandb.ai/borisd13/demo_config/reports/Visualize-track-compare-Fastai-models--Vmlldzo4MzAyNA) pour plus de détails. +Vous pouvez intégrer **fastai** à W&B à l’aide de la classe `WandbCallback` pour suivre les expériences, consigner des métriques et visualiser les performances du modèle pendant l’entraînement. Cette page explique comment configurer l’authentification, ajouter le callback à votre boucle d’entraînement et configurer la journalisation pour l’entraînement en processus unique comme pour l’entraînement distribué. Consultez cette [documentation interactive avec exemples](https://app.wandb.ai/borisd13/demo_config/reports/Visualize-track-compare-Fastai-models--Vmlldzo4MzAyNA) pour plus de détails.
## Inscrivez-vous et créez une clé API @@ -26,7 +26,7 @@ Pour installer localement la bibliothèque `wandb` et vous connecter : - 1. Définissez la [variable d'environnement](/fr/models/track/environment-variables/) `WANDB_API_KEY` sur votre clé API. + 1. Définissez la [variable d'environnement](/fr/models/track/environment-variables/) `WANDB_API_KEY` sur votre clé API. Remplacez les valeurs entre `<>` par les vôtres : ```bash export WANDB_API_KEY= @@ -52,8 +52,8 @@ Pour installer localement la bibliothèque `wandb` et vous connecter : ``` - - ```notebook + + ```python !pip install wandb import wandb @@ -66,6 +66,8 @@ Pour installer localement la bibliothèque `wandb` et vous connecter : ## Ajoutez le `WandbCallback` au `learner` ou à la méthode `fit`
+Pour commencer à journaliser vos runs d'entraînement fastai dans W&B, joignez le `WandbCallback` soit à un seul appel à `fit`, soit au `learner` lui-même. + ```python import wandb from fastai.callback.wandb import * @@ -80,39 +82,41 @@ learn.fit(..., cbs=WandbCallback()) learn = learner(..., cbs=WandbCallback()) ``` -Si vous utilisez la version 1 de Fastai, consultez la [documentation Fastai v1](/fr/models/integrations/fastai/v1/). + + Si vous utilisez la version 1 de fastai, consultez la [documentation fastai v1](/fr/models/integrations/fastai/v1/). +
## Arguments de WandbCallback
-`WandbCallback` accepte les arguments suivants : - -| Args | Description | -| --------------------------------- | ---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | -| log | Indique s’il faut journaliser les `gradients`, les `parameters`, `all` ou `None` du modèle (par défaut). Les pertes et les métriques sont toujours journalisées. | -| log_preds | indique si vous souhaitez journaliser des échantillons de prédictions (par défaut : `True`). | -| log_preds_every_epoch | indique s’il faut journaliser les prédictions à chaque époque ou seulement à la fin (par défaut : `False`) | -| log_model | indique si vous souhaitez journaliser votre modèle (par défaut : False). Cela nécessite également `SaveModelCallback` | -| model_name | Le nom du `file` à journaliser, remplace `SaveModelCallback` | -| log_dataset |
  • False (par défaut)
  • True journalise le dossier référencé par learn.dls.path.
  • un chemin peut être défini explicitement pour indiquer quel dossier journaliser.

Remarque : le sous-dossier "models" est toujours ignoré.

| -| dataset_name | nom du jeu de données journalisé (par défaut : `nom du dossier`). | -| valid_dl | `DataLoaders` contenant les éléments utilisés pour les échantillons de prédictions (par défaut : des éléments aléatoires de `learn.dls.valid`. | -| n_preds | nombre de prédictions journalisées (36 par défaut). | -| seed | utilisé pour définir les échantillons aléatoires. | +Utilisez les arguments suivants pour contrôler ce que `WandbCallback` journalise pendant l'entraînement : + +| Arguments | Description | +| ----------------------- | ---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | +| `log` | Indique s'il faut journaliser les `gradients`, les `parameters`, `all` ou `None` (par défaut) du modèle. Les pertes et les métriques sont toujours enregistrées. | +| `log_preds` | Indique s'il faut journaliser des échantillons de prédictions (par défaut, `True`). | +| `log_preds_every_epoch` | Indique s'il faut journaliser les prédictions à chaque époque ou uniquement à la fin (par défaut, `False`). | +| `log_model` | Indique s'il faut journaliser le modèle (par défaut, `False`). Cela nécessite également `SaveModelCallback`. | +| `model_name` | Le nom du `file` à enregistrer, remplace `SaveModelCallback`. | +| `log_dataset` |
  • False (par défaut).
  • True journalise le dossier référencé par `learn.dls.path`.
  • Vous pouvez définir explicitement un chemin pour indiquer quel dossier journaliser.

Remarque : le sous-dossier "models" est toujours ignoré.

| +| `dataset_name` | Nom du jeu de données enregistré (par défaut, nom du dossier). | +| `valid_dl` | `DataLoaders` contenant les éléments utilisés pour les échantillons de prédictions (par défaut, des éléments aléatoires de `learn.dls.valid`). | +| `n_preds` | Nombre de prédictions enregistrées (par défaut, 36). | +| `seed` | Utilisé pour définir des échantillons aléatoires. | Pour les flux de travail personnalisés, vous pouvez journaliser manuellement vos jeux de données et modèles : * `log_dataset(path, name=None, metadata={})` * `log_model(path, name=None, metadata={})` -*Remarque : tout sous-dossier "models" sera ignoré.* +*Remarque : tout sous-dossier "models" est ignoré.*
## Entraînement distribué
-`fastai` prend en charge l'entraînement distribué à l'aide du gestionnaire de contexte `distrib_ctx`. W&B le prend automatiquement en charge et vous permet de suivre vos expériences multi-GPU sans configuration supplémentaire. +`fastai` prend en charge l'entraînement distribué à l'aide du gestionnaire de contexte `distrib_ctx`. W&B le prend automatiquement en charge et vous permet de suivre vos expériences multi-GPU sans configuration supplémentaire. Les sections suivantes décrivent comment intégrer W&B à l'entraînement distribué et comment limiter la journalisation au processus principal. Voici un exemple minimal : @@ -148,13 +152,13 @@ Voici un exemple minimal : Ensuite, dans votre terminal, exécutez : ```shell - $ torchrun --nproc_per_node 2 train.py + torchrun --nproc_per_node 2 train.py ``` Dans ce cas, la machine dispose de 2 GPU. - + Vous pouvez désormais exécuter l'entraînement distribué directement dans un notebook. ```python @@ -191,7 +195,7 @@ Voici un exemple minimal : ### Journalisez uniquement depuis le processus principal
-Dans les exemples ci-dessus, `wandb` lance un run par processus. À la fin de l'entraînement, vous aurez donc deux runs. Cela peut parfois prêter à confusion, et vous pouvez vouloir journaliser uniquement depuis le processus principal. Pour ce faire, vous devez déterminer manuellement dans quel processus vous vous trouvez et éviter de créer des runs (en appelant `wandb.init()` dans tous les autres processus) +Dans les exemples précédents, W&B lance un run par processus. À la fin de l’entraînement, vous avez deux runs. Cela peut parfois prêter à confusion, et vous pouvez vouloir journaliser uniquement depuis le processus principal. Pour ce faire, vous devez détecter manuellement dans quel processus vous vous trouvez et éviter de créer des runs (en appelant `wandb.init()` dans tous les autres processus). @@ -205,36 +209,33 @@ Dans les exemples ci-dessus, `wandb` lance un run par processus. À la fin de l& path = rank0_first(lambda: untar_data(URLs.PETS) / "images") def train(): - cb = [] - dls = ImageDataLoaders.from_name_func( - path, - get_image_files(path), - valid_pct=0.2, - label_func=lambda x: x[0].isupper(), - item_tfms=Resize(224), - ) - if rank_distrib() == 0: - run = wandb.init("fastai_ddp", entity="capecape") - cb = WandbCallback() - learn = vision_learner(dls, resnet34, metrics=error_rate, cbs=cb).to_fp16() - with learn.distrib_ctx(sync_bn=False): - learn.fit(1) - - if **name** == "**main**": - train() - - ``` - - dans votre terminal, exécutez : + cb = [] + dls = ImageDataLoaders.from_name_func( + path, + get_image_files(path), + valid_pct=0.2, + label_func=lambda x: x[0].isupper(), + item_tfms=Resize(224), + ) + if rank_distrib() == 0: + run = wandb.init("fastai_ddp", entity="capecape") + cb = WandbCallback() + learn = vision_learner(dls, resnet34, metrics=error_rate, cbs=cb).to_fp16() + with learn.distrib_ctx(sync_bn=False): + learn.fit(1) + if __name__ == "__main__": + train() ``` - $ torchrun --nproc_per_node 2 train.py + Dans votre terminal, exécutez : + ```shell + torchrun --nproc_per_node 2 train.py ``` - + ```python import wandb from fastai.vision.all import * @@ -271,5 +272,7 @@ Dans les exemples ci-dessus, `wandb` lance un run par processus. À la fin de l& ## Exemples
+Pour des démonstrations de bout en bout de l’intégration fastai, voir les références suivantes : + * [Visualiser, suivre et comparer des modèles Fastai](https://app.wandb.ai/borisd13/demo_config/reports/Visualize-track-compare-Fastai-models--Vmlldzo4MzAyNA) : Un guide pas à pas très détaillé. * [Segmentation d’images sur CamVid](https://colab.research.google.com/drive/1IWrhwcJoncCKHm6VXsNwOr9Yukhz3B49?usp=sharing) : Un exemple d’utilisation de l’intégration. \ No newline at end of file diff --git a/fr/models/integrations/fastai/v1.mdx b/fr/models/integrations/fastai/v1.mdx index 7ce0e8e8c1..a8dad8cb5e 100644 --- a/fr/models/integrations/fastai/v1.mdx +++ b/fr/models/integrations/fastai/v1.mdx @@ -1,14 +1,14 @@ --- title: fastai v1 -description: "Utilisez le callback W&B avec fastai v1 pour enregistrer la topologie du modèle, les pertes, les métriques, les poids, les gradients et les prédictions." +description: "Utilisez le callback W&B avec fastai v1 pour journaliser la topologie du modèle, les pertes, les métriques, les poids, les gradients et les prédictions." --- Cette documentation concerne fastai v1. - Si vous utilisez la version actuelle de fastai, vous devriez vous référer à la [page fastai](../). + Si vous utilisez la version actuelle de fastai, voir la [page fastai](../). -Pour les scripts utilisant fastai v1, nous proposons un callback capable d'enregistrer automatiquement la topologie du modèle, les pertes, les métriques, les poids, les gradients, des exemples de prédictions et le meilleur modèle entraîné. +Pour les scripts fastai v1, W&B fournit un callback qui journalise automatiquement la topologie du modèle, les pertes, les métriques, les poids, les gradients, des exemples de prédictions et le meilleur modèle entraîné. ```python import wandb @@ -20,7 +20,7 @@ learn = cnn_learner(data, model, callback_fns=WandbCallback) learn.fit(epochs) ``` -Les données à enregistrer peuvent être configurées via le constructeur du callback. +Les données à journaliser peuvent être configurées via le constructeur du callback. ```python from functools import partial @@ -30,29 +30,26 @@ learn = cnn_learner( ) ``` -Il est également possible d’utiliser WandbCallback uniquement au démarrage de l’entraînement. Dans ce cas, vous devez l’instancier. +Vous pouvez également utiliser `WandbCallback` uniquement au démarrage de l’entraînement. Dans ce cas, vous devez l’instancier. ```python learn.fit(epochs, callbacks=WandbCallback(learn)) ``` -Des paramètres personnalisés peuvent également être spécifiés à cette étape. +Vous pouvez également spécifier des paramètres personnalisés à cette étape. ```python learn.fit(epochs, callbacks=WandbCallback(learn, input_type="images")) ``` -
## Exemples de code
-Nous avons créé quelques exemples pour vous permettre de voir comment l’intégration fonctionne : - -**Fastai v1** +Les exemples suivants montrent comment l’intégration fonctionne : -* [Classer les personnages des Simpson](https://github.com/borisdayma/simpsons-fastai)[: ](https://app.wandb.ai/jxmorris12/huggingface-demo/reports/A-Step-by-Step-Guide-to-Tracking-Hugging-Face-Model-Performance--VmlldzoxMDE2MTU)Une démo simple pour suivre et comparer les modèles Fastai -* [Segmentation sémantique avec Fastai](https://github.com/borisdayma/semantic-segmentation): Optimisation de réseaux neuronaux pour les voitures autonomes +* [Classer les personnages des Simpson](https://github.com/borisdayma/simpsons-fastai): Une démo pour suivre et comparer les modèles fastai. Voir le [guide étape par étape](https://app.wandb.ai/jxmorris12/huggingface-demo/reports/A-Step-by-Step-Guide-to-Tracking-Hugging-Face-Model-Performance--VmlldzoxMDE2MTU). +* [Segmentation sémantique avec Fastai](https://github.com/borisdayma/semantic-segmentation): Optimisation de réseaux neuronaux pour les voitures autonomes.
## Options @@ -60,14 +57,14 @@ Nous avons créé quelques exemples pour vous permettre de voir comment l’int La classe `WandbCallback()` prend en charge plusieurs options : -| Argument mot-clé | Par défaut | Description | -| ------------------- | ---------- | -------------------------------------------------------------------------------------------------------------------------------------------------------------------- | -| learn | N/A | le learner fast.ai à utiliser. | -| save_model | True | enregistre le modèle s'il s'améliore à chaque étape. Charge également le meilleur modèle à la fin de l'entraînement. | -| mode | auto | `min`, `max` ou `auto` : comment comparer la métrique d'entraînement spécifiée dans `monitor` d'une étape à l'autre. | -| monitor | None | métrique d'entraînement utilisée pour mesurer les performances afin d'enregistrer le meilleur modèle. `None` correspond par défaut à la perte de validation. | -| log | gradients | `gradients`, `parameters`, `all` ou None. Les pertes et les métriques sont toujours enregistrées. | -| input_type | None | `images` ou `None`. Utilisé pour afficher des exemples de prédictions. | -| validation_data | None | données utilisées pour les exemples de prédictions si `input_type` est défini. | -| predictions | 36 | nombre de prédictions à effectuer si `input_type` est défini et que `validation_data` est `None`. | -| seed | 12345 | initialise le générateur aléatoire pour les exemples de prédictions si `input_type` est défini et que `validation_data` est `None`. | \ No newline at end of file +| Keyword argument | Par défaut | Description | +| ----------------- | ----------- | --------------------------------------------------------------------------------------------------------------------------------------------------------------------- | +| `learn` | N/A | Le learner fast.ai à associer. | +| `save_model` | `True` | Enregistre le modèle s'il s'améliore à chaque étape. Charge également le meilleur modèle à la fin de l'entraînement. | +| `mode` | `auto` | `min`, `max` ou `auto`. Indique comment comparer, d'une étape à l'autre, la métrique d'entraînement spécifiée dans `monitor`. | +| `monitor` | `None` | Métrique d'entraînement utilisée pour mesurer les performances lors de l'enregistrement du meilleur modèle. `None` utilise par défaut la perte de validation. | +| `log` | `gradients` | `gradients`, `parameters`, `all` ou `None`. Les pertes et les métriques sont toujours journalisées. | +| `input_type` | `None` | `images` ou `None`. Utilisé pour afficher des exemples de prédictions. | +| `validation_data` | `None` | Données utilisées pour les exemples de prédictions si `input_type` est défini. | +| `predictions` | `36` | Nombre de prédictions à effectuer si `input_type` est défini et que `validation_data` vaut `None`. | +| `seed` | `12345` | Initialise le générateur aléatoire pour les exemples de prédictions si `input_type` est défini et que `validation_data` vaut `None`. | \ No newline at end of file diff --git a/fr/models/integrations/huggingface.mdx b/fr/models/integrations/huggingface.mdx index 945897b538..713f75252e 100644 --- a/fr/models/integrations/huggingface.mdx +++ b/fr/models/integrations/huggingface.mdx @@ -7,42 +7,42 @@ import { ColabLink } from '/snippets/fr/_includes/colab-link.mdx'; -Visualisez rapidement les performances de votre modèle [Hugging Face](https://github.com/huggingface/transformers) grâce à une intégration fluide avec [W&B](https://wandb.ai/site). +Ce tutoriel vous montre comment utiliser l’intégration W&B avec [Hugging Face Transformers](https://github.com/huggingface/transformers) pour suivre automatiquement les métriques d’entraînement et d’évaluation, les hyperparamètres et les statistiques système lors du fine-tuning d’un modèle. En suivant ce tutoriel, vous apprendrez à visualiser les performances de votre modèle dans le tableau de bord [W&B](https://wandb.ai/site) afin de comparer les expériences et d’itérer sur vos modèles en toute confiance. -Comparez les hyperparamètres, les métriques de sortie et les statistiques système, comme l’utilisation du GPU, entre vos modèles. +Vous pouvez comparer les hyperparamètres, les métriques de sortie et les statistiques système, comme l’utilisation du GPU, entre vos modèles. -
- ## Pourquoi utiliser W&B ? +
+ ## Pourquoi utiliser W&B
- Avantages de l'utilisation de W&B + Avantages de l’utilisation de W&B -* **Tableau de bord unifié** : dépôt central pour toutes les métriques et prédictions de votre modèle -* **Léger** : aucune modification du code n'est nécessaire pour intégrer Hugging Face -* **Accessible** : gratuit pour les particuliers et les équipes universitaires -* **Sécurisé** : tous les projets sont privés par défaut -* **Fiable** : utilisé par des équipes de machine learning chez OpenAI, Toyota, Lyft, et bien d'autres +* **Tableau de bord unifié** : dépôt central pour toutes les métriques et prédictions de votre modèle. +* **Léger** : aucune modification du code n’est nécessaire pour l’intégrer à Hugging Face. +* **Accessible** : gratuit pour les particuliers et les équipes universitaires. +* **Sécurisé** : tous les projets sont privés par défaut. +* **Fiable** : utilisé par des équipes de machine learning chez OpenAI, Toyota, Lyft et bien d’autres. -Considérez W&B comme le GitHub des modèles de machine learning : enregistrez vos expériences de machine learning dans votre tableau de bord privé et hébergé. Expérimentez rapidement en ayant l'assurance que toutes les versions de vos modèles sont enregistrées, où que vous exécutiez vos scripts. +W&B fonctionne comme GitHub pour les modèles de machine learning. Enregistrez vos expériences de machine learning dans votre tableau de bord privé hébergé. Expérimentez en toute confiance : W&B enregistre toutes les versions de vos modèles, quel que soit l’endroit où vous exécutez vos scripts. -Les intégrations légères de W&B fonctionnent avec n'importe quel script Python, et il vous suffit de créer gratuitement un compte W&B pour commencer à suivre et visualiser vos modèles. +Les intégrations légères de W&B fonctionnent avec n’importe quel script Python. Inscrivez-vous pour obtenir un compte W&B gratuit et commencer à suivre et à visualiser vos modèles. -Dans le dépôt Transformers de Hugging Face, nous avons instrumenté le Trainer pour consigner automatiquement les métriques d'entraînement et d'évaluation dans W&B à chaque étape de logging. +Dans le dépôt Hugging Face Transformers, W&B a instrumenté le Trainer pour journaliser automatiquement les métriques d’entraînement et d’évaluation vers W&B à chaque étape de journalisation. -Voici un aperçu détaillé du fonctionnement de l'intégration : [Rapport Hugging Face + W&B](https://app.wandb.ai/jxmorris12/huggingface-demo/reports/Train-a-model-with-Hugging-Face-and-Weights-%26-Biases--VmlldzoxMDE2MTU). +Voici un aperçu détaillé du fonctionnement de l’intégration : [Hugging Face + W&B Report](https://app.wandb.ai/jxmorris12/huggingface-demo/reports/Train-a-model-with-Hugging-Face-and-Weights-%26-Biases--VmlldzoxMDE2MTU).
- ## Installer, importer et se connecter + ## Installez, importez et connectez-vous
-Installez les bibliothèques Hugging Face et W&B, ainsi que le jeu de données GLUE et le script d'entraînement nécessaires pour ce tutoriel. +Cette section configure l’environnement nécessaire pour exécuter le tutoriel. Installez les bibliothèques Hugging Face et W&B, puis téléchargez le dataset GLUE et le script d’entraînement pour ce tutoriel : -* [Hugging Face Transformers](https://github.com/huggingface/transformers): Modèles et jeux de données pour le traitement du langage naturel -* [W&B](/fr/): Suivi des expériences et visualisation -* [GLUE dataset](https://gluebenchmark.com/): Jeu de données de référence pour la compréhension du langage -* [GLUE script](https://raw.githubusercontent.com/huggingface/transformers/refs/heads/main/examples/pytorch/text-classification/run_glue.py): Script d'entraînement du modèle pour la classification de séquences +* [Hugging Face Transformers](https://github.com/huggingface/transformers) : modèles et datasets de traitement du langage naturel. +* [W&B](/fr/) : suivi des expériences et visualisation. +* [GLUE dataset](https://gluebenchmark.com/) : dataset de référence pour la compréhension du langage. +* [GLUE script](https://raw.githubusercontent.com/huggingface/transformers/refs/heads/main/examples/pytorch/text-classification/run_glue.py) : script d’entraînement de modèle pour la classification de séquences. ```notebook !pip install datasets wandb evaluate accelerate -qU @@ -50,27 +50,27 @@ Installez les bibliothèques Hugging Face et W&B, ainsi que le jeu de donné ``` ```notebook -# le script run_glue.py nécessite transformers dev +# le script run_glue.py nécessite la version Dév de transformers !pip install -q git+https://github.com/huggingface/transformers ``` -Avant de continuer, [inscrivez-vous pour obtenir un compte gratuit](https://app.wandb.ai/login?signup=true). +Avant de continuer, vous devez [vous inscrire pour créer un compte gratuit](https://app.wandb.ai/login?signup=true). Un compte est requis pour envoyer les données de votre run à un tableau de bord W&B. -
- ## Saisissez votre clé API +
+ ## Ajoutez votre clé API
-Une fois votre inscription terminée, exécutez la cellule suivante, puis cliquez sur le lien pour obtenir votre clé API et authentifier ce notebook. +L’authentification à l’aide de votre clé API associe ce notebook à votre compte W&B, afin que les runs soient enregistrés dans vos projets. Après votre inscription, exécutez la cellule suivante et cliquez sur le lien pour obtenir votre clé API et authentifier ce notebook. ```python import wandb wandb.login() ``` -Vous pouvez, si vous le souhaitez, définir des variables d’environnement pour personnaliser le logging de W&B. Voir le [guide d’intégration Hugging Face](/fr/models/integrations/huggingface/). +Si vous le souhaitez, vous pouvez définir des variables d'environnement pour personnaliser ce que W&B journalise pendant l'entraînement. Par exemple, vous pouvez journaliser à la fois les gradients et les paramètres en définissant `WANDB_WATCH=all`. Voir le [guide d'intégration Hugging Face](/fr/models/integrations/huggingface/) pour la liste complète des options. ```python -# Facultatif : journaliser les gradients et les paramètres +# Facultatif : journaliser à la fois les gradients et les paramètres %env WANDB_WATCH=all ``` @@ -78,7 +78,7 @@ Vous pouvez, si vous le souhaitez, définir des variables d’environnement pour ## Entraîner le modèle
-Ensuite, exécutez le script d'entraînement téléchargé [run_glue.py](https://huggingface.co/transformers/examples.html#glue) et constatez que l'entraînement est automatiquement suivi dans le tableau de bord W&B. Ce script effectue le fine-tuning de BERT sur le Microsoft Research Paraphrase Corpus — des paires de phrases avec des annotations humaines indiquant si elles sont sémantiquement équivalentes. +Une fois l’environnement configuré et l’authentification terminée, vous êtes prêt à démarrer un run d’entraînement. Ensuite, exécutez le script d’entraînement téléchargé [`run_glue.py`](https://huggingface.co/transformers/examples.html#glue) et constatez que l’entraînement est automatiquement suivi dans le tableau de bord W&B. Ce script effectue le fine-tuning de BERT sur le Microsoft Research Paraphrase Corpus — des paires de phrases avec des annotations humaines indiquant si elles sont sémantiquement équivalentes. ```python %env WANDB_PROJECT=huggingface-demo @@ -98,36 +98,42 @@ Ensuite, exécutez le script d'entraînement téléchargé [run_glue.py] --logging_steps 50 ``` -
+
## Visualisez les résultats dans le tableau de bord
-Cliquez sur le lien affiché ci-dessus ou rendez-vous sur [wandb.ai](https://app.wandb.ai) pour voir vos résultats s’afficher en direct. Le lien pour voir votre run dans le navigateur apparaîtra une fois toutes les dépendances chargées. Recherchez la sortie suivante : "**wandb**: View run at [URL to your unique run]" +Une fois l’entraînement lancé, vous pouvez surveiller les métriques en temps réel. Cliquez sur le lien affiché par la cellule précédente ou rendez-vous sur [wandb.ai](https://app.wandb.ai) pour voir vos résultats s’afficher en direct. Le lien pour voir votre run dans le navigateur apparaît une fois toutes les dépendances chargées. Recherchez la sortie suivante : "**wandb**: View run at [URL to your unique run]" -**Visualisez les performances du modèle** -Il est facile de parcourir des dizaines d’expériences, de zoomer sur les résultats intéressants et de visualiser des données à forte dimensionnalité. +
+ ### Visualisez les performances du modèle +
+ +Parcourez les expériences, zoomez sur les résultats intéressants et visualisez des données à forte dimensionnalité. Tableau de bord des métriques du modèle -**Comparez les architectures** -Voici un exemple comparant [BERT vs DistilBERT](https://app.wandb.ai/jack-morris/david-vs-goliath/reports/Does-model-size-matter%3F-Comparing-BERT-and-DistilBERT-using-Sweeps--VmlldzoxMDUxNzU). Il est facile de voir comment différentes architectures influencent la précision de l’évaluation tout au long de l’entraînement grâce à des graphiques en courbes générés automatiquement. +
+ ### Comparez les architectures +
+ +Voici un exemple comparant [BERT versus DistilBERT](https://app.wandb.ai/jack-morris/david-vs-goliath/reports/Does-model-size-matter%3F-Comparing-BERT-and-DistilBERT-using-Sweeps--VmlldzoxMDUxNzU). Les graphiques en courbes générés automatiquement montrent comment différentes architectures influencent la précision de l’évaluation tout au long de l’entraînement. - Comparaison BERT vs DistilBERT + Comparaison BERT versus DistilBERT -
- ## Suivez automatiquement les informations essentielles +
+ ## Suivre automatiquement les informations clés
-W&B enregistre un nouveau run pour chaque expérience. Voici les informations enregistrées par défaut : +Cette section décrit ce que W&B capture automatiquement afin que vous sachiez quelles données sont disponibles dans votre tableau de bord sans configuration supplémentaire. W&B enregistre un nouveau run pour chaque expérience. Voici les informations enregistrées par défaut : -* **Hyperparamètres** : les paramètres de votre modèle sont enregistrés dans Config -* **Métriques du modèle** : les séries temporelles de métriques reçues en continu sont enregistrées dans Log -* **Journaux du terminal** : les sorties de la ligne de commande sont enregistrées et disponibles dans un onglet -* **Métriques système** : utilisation du GPU et du CPU, mémoire, température, etc. +* **Hyperparamètres** : W&B enregistre les paramètres de votre modèle dans Config. +* **Métriques du modèle** : W&B enregistre les données de séries temporelles des métriques envoyées à Log. +* **Journaux du terminal** : W&B enregistre les sorties de la ligne de commande et les affiche dans un onglet. +* **Métriques système** : utilisation du GPU et du CPU, mémoire et température.
## En savoir plus diff --git a/fr/models/integrations/huggingface_transformers.mdx b/fr/models/integrations/huggingface_transformers.mdx index 5a2dd29ed4..f45f52a636 100644 --- a/fr/models/integrations/huggingface_transformers.mdx +++ b/fr/models/integrations/huggingface_transformers.mdx @@ -8,14 +8,16 @@ import ApiKeyCreateStreamlined from "/snippets/fr/_includes/api-key-create-strea -La bibliothèque [Hugging Face Transformers](https://huggingface.co/docs/transformers/index) simplifie l’utilisation de modèles NLP de pointe comme BERT et de techniques d’entraînement comme la précision mixte et le gradient checkpointing. L’[intégration W&B](https://huggingface.co/transformers/main_classes/callback.html#transformers.integrations.WandbCallback) ajoute un suivi des expériences riche et flexible ainsi que la gestion des versions des modèles dans des tableaux de bord centralisés interactifs, sans rien sacrifier à cette simplicité d’utilisation. +La bibliothèque [Hugging Face Transformers](https://huggingface.co/docs/transformers/index) simplifie l’utilisation de modèles NLP comme BERT et de techniques d’entraînement comme la précision mixte et le gradient checkpointing. L’[intégration W&B](https://huggingface.co/transformers/main_classes/callback.html#transformers.integrations.WandbCallback) ajoute le suivi des expériences et la gestion des versions des modèles à des tableaux de bord centralisés. -
- ## Journalisation avancée en quelques lignes +Ce guide vous montre comment connecter le `Trainer` de Hugging Face à W&B. Vos run d’entraînement consigneront alors automatiquement les métriques, les points de contrôle du modèle et les sorties d’évaluation dans un tableau de bord centralisé. À la fin, vous serez en mesure de comparer les run, d’enregistrer et de recharger des points de contrôle du modèle depuis W&B Artifacts, et de personnaliser la journalisation pour vos propres flux de travail. Ce guide suppose que vous êtes déjà familiarisé avec l’entraînement de modèles à l’aide du `Trainer` de Hugging Face Transformers. + +
+ ## Démarrage rapide
```python -os.environ["WANDB_PROJECT"] = "" # nommez votre projet W&B +os.environ["WANDB_PROJECT"] = "" # nommez votre projet W&B os.environ["WANDB_LOG_MODEL"] = "checkpoint" # journaliser tous les points de contrôle du modèle from transformers import TrainingArguments, Trainer @@ -25,15 +27,19 @@ trainer = Trainer(..., args=args) ``` - tableau de bord HuggingFace + tableau de bord Hugging Face -Si vous préférez passer directement à du code prêt à l’emploi, consultez ce [Google Colab](https://wandb.me/hf). + + Si vous préférez passer directement à du code prêt à l’emploi, consultez ce [Google Colab](https://wandb.me/hf). +
## Premiers pas : suivre les expériences
+Cette section explique comment vous authentifier auprès de W&B, installer la bibliothèque cliente, donner un nom à votre projet et activer la journalisation dans votre `Trainer` afin que votre premier run d'entraînement s'affiche dans le tableau de bord W&B. +
### Inscrivez-vous et créez une clé API
@@ -53,7 +59,7 @@ Pour installer la bibliothèque `wandb` localement et vous connecter : - 1. Définissez la [variable d'environnement](/fr/models/track/environment-variables/) `WANDB_API_KEY` sur votre clé API. + 1. Définissez la [variable d'environnement](/fr/models/track/environment-variables/) `WANDB_API_KEY` sur votre clé API. Remplacez les valeurs entre `<>` par les vôtres : ```bash export WANDB_API_KEY= @@ -61,7 +67,7 @@ Pour installer la bibliothèque `wandb` localement et vous connecter : 2. Installez la bibliothèque `wandb` et connectez-vous. - ```shell + ```bash pip install wandb wandb login @@ -89,15 +95,15 @@ Pour installer la bibliothèque `wandb` localement et vous connecter : -Si vous utilisez W&B pour la première fois, vous pouvez consulter notre [démarrage rapide](/fr/models/quickstart/) +Si vous utilisez W&B pour la première fois, consultez le [démarrage rapide](/fr/models/quickstart/).
### Nommez le projet
-Un projet W&B est l’endroit où sont stockés tous les graphiques, les données et les modèles enregistrés à partir de runs liés. Donner un nom à votre projet vous aide à organiser votre travail et à regrouper au même endroit toutes les informations relatives à un même projet. +Un projet W&B stocke tous les graphiques, les données et les modèles enregistrés à partir de runs liés. Donner un nom à votre projet vous aide à organiser votre travail et à regrouper au même endroit toutes les informations relatives à un même projet. -Pour ajouter un run à un projet, définissez simplement la variable d’environnement `WANDB_PROJECT` sur le nom de votre projet. Le `WandbCallback` récupérera cette variable d’environnement et l’utilisera lors de la configuration de votre run. +Pour ajouter un run à un projet, définissez la variable d’environnement `WANDB_PROJECT` sur le nom de votre projet. Le `WandbCallback` récupère cette variable d’environnement de nom de projet et l’utilise lors de la configuration de votre run. @@ -124,17 +130,17 @@ Pour ajouter un run à un projet, définissez simplement la variable d’environ Assurez-vous de définir le nom du projet *avant* d’initialiser le `Trainer`. -Si aucun nom de projet n’est spécifié, le nom du projet est `huggingface` par défaut. +Si vous ne spécifiez pas de nom de projet, le nom du projet est `huggingface` par défaut.
### Enregistrez vos runs d'entraînement dans W&B
-Lorsque vous définissez les arguments d'entraînement de votre `Trainer`, dans votre code ou en ligne de commande, **l'étape la plus importante** consiste à définir `report_to` sur `"wandb"` afin d'activer la journalisation avec W&B. +Lorsque vous définissez les arguments d'entraînement de votre `Trainer`, dans votre code ou en ligne de commande, définissez `report_to` sur `"wandb"` afin d'activer la journalisation avec W&B. Sans ce paramètre, le `Trainer` n'envoie aucune donnée à W&B. L'argument `logging_steps` dans `TrainingArguments` contrôle la fréquence à laquelle les métriques d'entraînement sont envoyées à W&B pendant l'entraînement. Vous pouvez aussi donner un nom au run d'entraînement dans W&B à l'aide de l'argument `run_name`. -C'est tout. Désormais, vos modèles journaliseront les pertes, les métriques d'évaluation, l'architecture du modèle et les gradients dans W&B pendant leur entraînement. +C'est tout. Désormais, vos modèles journalisent les pertes, les métriques d'évaluation, l'architecture du modèle et les gradients dans W&B pendant leur entraînement. @@ -150,40 +156,40 @@ C'est tout. Désormais, vos modèles journaliseront les pertes, les métriqu ```python from transformers import TrainingArguments, Trainer - args = TrainingArguments( # autres args et kwargs ici - report_to="wandb", # activez la journalisation vers W&B - run_name="bert-base-high-lr", # nom du run W&B (facultatif) - logging_steps=1, # fréquence de journalisation vers W&B + args = TrainingArguments( + # autres args et kwargs ici + report_to="wandb", # activez la journalisation vers W&B + run_name="bert-base-high-lr", # nom du run W&B (facultatif) + logging_steps=1, # fréquence de journalisation vers W&B ) - trainer = Trainer( # autres args et kwargs ici - args=args, # vos arguments d'entraînement + trainer = Trainer( + # autres args et kwargs ici + args=args, # vos arguments d'entraînement ) - trainer.train() # démarrez l'entraînement et la journalisation vers W&B - + trainer.train() # démarrez l'entraînement et la journalisation vers W&B ``` - Vous utilisez TensorFlow ? Remplacez simplement le `Trainer` de PyTorch par le `TFTrainer` de TensorFlow. + Vous utilisez TensorFlow ? Remplacez le `Trainer` de PyTorch par le `TFTrainer` de TensorFlow. -``` -``` -
### Activez l'enregistrement des points de contrôle du modèle
-Avec [Artifacts](/fr/models/artifacts/), vous pouvez stocker gratuitement jusqu'à 100 Go de modèles et de jeux de données, puis utiliser le [registre W&B](/fr/models/registry/). Avec le registre, vous pouvez enregistrer des modèles pour les explorer et les évaluer, les préparer pour la préproduction ou les déployer dans votre environnement de production. +En plus de consigner des métriques, vous pouvez enregistrer les poids du modèle entraîné eux-mêmes dans W&B afin qu’ils puissent être versionnés, téléchargés et partagés au sein de votre équipe. + +Avec [Artifacts](/fr/models/artifacts/), vous pouvez stocker gratuitement jusqu'à 100 Go de modèles et de jeux de données, puis utiliser le [registre](/fr/models/registry/). Avec le registre, vous pouvez enregistrer des modèles pour les explorer et les évaluer, les préparer pour la préproduction ou les déployer dans votre environnement de production. Pour journaliser les points de contrôle de votre modèle Hugging Face dans Artifacts, définissez la variable d'environnement `WANDB_LOG_MODEL` sur *l'une* des valeurs suivantes : -* **`checkpoint`**: Téléverse un point de contrôle tous les `args.save_steps` à partir de [`TrainingArguments`](https://huggingface.co/docs/transformers/main/en/main_classes/trainer#transformers.TrainingArguments). -* **`end`**: Téléverse le modèle à la fin de l'entraînement, si `load_best_model_at_end` est également défini. -* **`false`**: Ne téléverse pas le modèle. +* **`checkpoint`** : Téléverse un point de contrôle tous les `args.save_steps` à partir de [`TrainingArguments`](https://huggingface.co/docs/transformers/main/en/main_classes/trainer#transformers.TrainingArguments). +* **`end`** : Téléverse le modèle à la fin de l'entraînement, si `load_best_model_at_end` est également défini. +* **`false`** : Ne téléverse pas le modèle. @@ -207,42 +213,42 @@ Pour journaliser les points de contrôle de votre modèle Hugging Face dans Arti -Tous les `Trainer` Transformers que vous initialisez à partir de maintenant téléverseront des modèles dans votre projet W&B. Les points de contrôle du modèle que vous journalisez seront visibles dans l'interface [Artifacts](/fr/models/artifacts/) et incluront la traçabilité complète du modèle (voir un exemple de point de contrôle du modèle dans l'interface [ici](https://wandb.ai/wandb/arttest/artifacts/model/iv3_trained/5334ab69740f9dda4fed/lineage?_gl=1*yyql5q*_ga*MTQxOTYyNzExOS4xNjg0NDYyNzk1*_ga_JH1SJHJQXJ*MTY5MjMwNzI2Mi4yNjkuMS4xNjkyMzA5NjM2LjM3LjAuMA..)). +Tous les `Trainer` Transformers que vous initialisez à partir de maintenant téléversent des modèles dans votre projet W&B. Les points de contrôle du modèle que vous journalisez sont visibles dans l'interface [Artifacts](/fr/models/artifacts/) et incluent la traçabilité complète du modèle. Voir un [exemple de point de contrôle du modèle dans l'interface Artifacts](https://wandb.ai/wandb/arttest/artifacts/model/iv3_trained/5334ab69740f9dda4fed/lineage?_gl=1*yyql5q*_ga*MTQxOTYyNzExOS4xNjg0NDYyNzk1*_ga_JH1SJHJQXJ*MTY5MjMwNzI2Mi4yNjkuMS4xNjkyMzA5NjM2LjM3LjAuMA..). - Par défaut, votre modèle sera enregistré dans W&B Artifacts sous la forme `model-{run_id}` lorsque `WANDB_LOG_MODEL` est défini sur `end`, ou `checkpoint-{run_id}` lorsque `WANDB_LOG_MODEL` est défini sur `checkpoint`. - Cependant, si vous transmettez un [`run_name`](https://huggingface.co/docs/transformers/main/en/main_classes/trainer#transformers.TrainingArguments.run_name) dans vos `TrainingArguments`, le modèle sera enregistré sous la forme `model-{run_name}` ou `checkpoint-{run_name}`. + Par défaut, votre modèle est enregistré dans W&B Artifacts sous la forme `model-{run_id}` lorsque `WANDB_LOG_MODEL` est défini sur `end`, ou `checkpoint-{run_id}` lorsque `WANDB_LOG_MODEL` est défini sur `checkpoint`. + Cependant, si vous transmettez un [`run_name`](https://huggingface.co/docs/transformers/main/en/main_classes/trainer#transformers.TrainingArguments.run_name) dans vos `TrainingArguments`, le modèle est enregistré sous la forme `model-{run_name}` ou `checkpoint-{run_name}`.
#### W&B registre
-Une fois vos point de contrôle du modèle enregistrés dans Artifacts, vous pouvez enregistrer les point de contrôle du modèle de vos meilleurs modèles et les centraliser au sein de votre équipe avec [registre](/fr/models/registry/). Avec le registre, vous pouvez organiser vos meilleurs modèles par tâche, gérer le cycle de vie des modèles, suivre et auditer l'ensemble du cycle de vie du machine learning, et [automatiser](/fr/models/automations/) les actions en aval. +Après avoir enregistré vos point de contrôle du modèle dans Artifacts, vous pouvez enregistrer les point de contrôle du modèle de vos meilleurs modèles et les centraliser au sein de votre équipe avec [registre](/fr/models/registry/). Avec le registre, vous pouvez organiser vos meilleurs modèles par tâche, gérer le cycle de vie des modèles, suivre et auditer l'ensemble du cycle de vie du machine learning, et [automatiser](/fr/models/automations/) les actions en aval. Pour lier un Artifact de modèle, reportez-vous à [registre](/fr/models/registry/). -
+
### Visualiser les sorties d’évaluation pendant l’entraînement
-Visualiser les sorties de votre modèle pendant l’entraînement ou l’évaluation est souvent essentiel pour bien comprendre comment votre modèle s’entraîne. +Visualiser les sorties de votre modèle pendant l’entraînement ou l’évaluation est souvent essentiel pour comprendre comment il apprend. Examiner des prédictions concrètes en parallèle des courbes de perte vous aide à repérer des problèmes de qualité que des métriques agrégées peuvent masquer. -En utilisant le système de callbacks du Transformers Trainer, vous pouvez journaliser dans W&B des données supplémentaires utiles, comme les sorties de génération de texte de vos modèles ou d’autres prédictions, dans W&B Tables. +Grâce au système de callbacks du Transformers Trainer, vous pouvez journaliser des données plus utiles dans les tableaux W&B. Cela inclut les sorties de génération de texte de vos modèles ou d’autres prédictions. -Voir la [section de journalisation personnalisée](#custom-logging-log-and-view-evaluation-samples-during-training) ci-dessous pour un guide complet expliquant comment journaliser les sorties d’évaluation pendant l’entraînement dans W&B Tables, comme ceci : +Pour obtenir un guide complet sur la façon de journaliser les sorties d’évaluation pendant l’entraînement dans un tableau W&B comme celui ci-dessous, voir [Journaliser et afficher des échantillons d’évaluation pendant l’entraînement](#log-and-view-evaluation-samples-during-training). - Montre une table W&B avec des sorties d’évaluation + Affiche un tableau W&B avec des sorties d’évaluation
- ### Terminez votre run W&B (Notebook uniquement) + ### Terminez votre run W&B (notebook uniquement)
-Si votre entraînement est encapsulé dans un script Python, le run W&B se terminera à la fin de l’exécution du script. +Si votre entraînement est encapsulé dans un script Python, le run W&B se termine à la fin de l’exécution du script. -Si vous utilisez un notebook Jupyter ou Google Colab, vous devrez nous indiquer que l’entraînement est terminé en appelant `run.finish()`. +Si vous utilisez un notebook Jupyter ou Google Colab, appelez `run.finish()` pour indiquer que l’entraînement est terminé. ```python run = wandb.init() @@ -257,14 +263,18 @@ run.finish() ### Visualisez vos résultats
-Une fois les résultats de votre entraînement enregistrés, vous pouvez les explorer de façon dynamique dans le [tableau de bord W&B](/fr/models/track/workspaces/). Vous pouvez facilement comparer des dizaines de runs à la fois, zoomer sur des résultats intéressants et tirer des enseignements de données complexes grâce à des visualisations flexibles et interactives. +Après avoir journalisé vos résultats d’entraînement, vous pouvez les explorer dans le [tableau de bord W&B](/fr/models/track/workspaces/). Vous pouvez comparer des run, examiner de plus près vos observations et explorer vos données à l’aide de visualisations interactives. + +À ce stade, vous disposez d’une intégration fonctionnelle : votre `Trainer` journalise des métriques dans un projet spécifié, enregistre éventuellement des points de contrôle du modèle dans Artifacts et affiche les sorties d’évaluation dans le tableau de bord W&B.
## Fonctionnalités avancées et FAQ
-
- ### Comment puis-je enregistrer le meilleur modèle ? +Les sections suivantes abordent des tâches complémentaires courantes, comme l’enregistrement du meilleur modèle, la reprise de l’entraînement à partir d’un point de contrôle, la personnalisation des callbacks de journalisation et la configuration du comportement de W&B via des variables d’environnement. + +
+ ### Enregistrer le meilleur modèle
Si vous transmettez `TrainingArguments` avec `load_best_model_at_end=True` à votre `Trainer`, W&B enregistre le point de contrôle du modèle le plus performant dans Artifacts. @@ -276,11 +286,11 @@ Si vous enregistrez les points de contrôle de votre modèle dans Artifacts, vou * Préparer les modèles pour la production ou les marquer pour une évaluation plus approfondie. * Déclencher des processus CI/CD en aval. -
- ### Comment puis-je charger un modèle enregistré ? +
+ ### Charger un modèle enregistré
-Si vous avez enregistré votre modèle dans W&B Artifacts avec `WANDB_LOG_MODEL`, vous pouvez télécharger les poids de votre modèle pour poursuivre l’entraînement ou effectuer de l’inférence. Il vous suffit ensuite de les recharger dans la même architecture Hugging Face que celle utilisée précédemment. +Si vous avez enregistré votre modèle dans W&B Artifacts avec `WANDB_LOG_MODEL`, vous pouvez télécharger les poids de votre modèle pour poursuivre l’entraînement ou effectuer de l’inférence. Rechargez-les dans la même architecture Hugging Face que celle utilisée précédemment. ```python # Créer un nouveau run @@ -301,11 +311,11 @@ with wandb.init(project="amazon_sentiment_analysis") as run: # Effectuer un entraînement supplémentaire ou exécuter l'inférence ``` -
- ### Comment puis-je reprendre l’entraînement à partir d’un point de contrôle ? +
+ ### Reprendre l’entraînement à partir d’un point de contrôle
-Si vous avez défini `WANDB_LOG_MODEL='checkpoint'`, vous pouvez également reprendre l’entraînement en utilisant `model_dir` comme valeur de l’argument `model_name_or_path` dans vos `TrainingArguments`, puis en passant `resume_from_checkpoint=True` à `Trainer`. +Si vous définissez `WANDB_LOG_MODEL='checkpoint'`, vous pouvez reprendre l’entraînement en utilisant `model_dir` comme valeur de l’argument `model_name_or_path` dans vos `TrainingArguments` et en passant `resume_from_checkpoint=True` à `Trainer`. ```python last_run_id = "xxxxxxxx" # fetch the run_id from your wandb workspace @@ -325,9 +335,9 @@ with wandb.init( # reinitialize your model and trainer model = AutoModelForSequenceClassification.from_pretrained( - "", num_labels=num_labels + "", num_labels=num_labels ) - # your awesome training arguments here. + # vos arguments d'entraînement ici. training_args = TrainingArguments() trainer = Trainer(model=model, args=training_args) @@ -336,13 +346,13 @@ with wandb.init( trainer.train(resume_from_checkpoint=checkpoint_dir) ``` -
- ### Comment puis-je journaliser et afficher des échantillons d’évaluation pendant l’entraînement +
+ ### Journaliser et afficher des échantillons d’évaluation pendant l’entraînement
-La journalisation dans W&B via le `Trainer` de Transformers est assurée par le [`WandbCallback`](https://huggingface.co/transformers/main_classes/callback.html#transformers.integrations.WandbCallback) de la bibliothèque Transformers. Si vous devez personnaliser votre journalisation Hugging Face, vous pouvez modifier ce callback en créant une sous-classe de `WandbCallback` et en ajoutant des fonctionnalités supplémentaires qui s’appuient sur d’autres méthodes de la classe Trainer. +Le [`WandbCallback`](https://huggingface.co/transformers/main_classes/callback.html#transformers.integrations.WandbCallback) de la bibliothèque Transformers gère la journalisation dans W&B via le `Trainer` de Transformers. Vous pouvez personnaliser ce callback pour journaliser les prédictions du modèle, des matrices de confusion ou d’autres données personnalisées. Pour ce faire, créez une sous-classe de `WandbCallback` et ajoutez des fonctionnalités qui utilisent des méthodes supplémentaires de la classe Trainer. -Vous trouverez ci-dessous le schéma général pour ajouter ce nouveau callback au Trainer HF, puis plus bas un exemple de code complet pour journaliser les sorties d’évaluation dans un tableau W&B : +Vous trouverez ci-dessous le schéma général pour ajouter ce nouveau callback au Hugging Face Trainer, suivi d’un exemple de code complet pour journaliser les sorties d’évaluation dans un tableau W&B : ```python # Instancier le Trainer normalement @@ -362,17 +372,17 @@ trainer.train() #### Afficher des échantillons d’évaluation pendant l’entraînement
-La section suivante montre comment personnaliser le `WandbCallback` pour exécuter les prédictions du modèle et journaliser des échantillons d’évaluation dans un tableau W&B pendant l’entraînement. Nous le faisons tous les `eval_steps` en utilisant la méthode `on_evaluate` du callback du `Trainer`. +La section suivante montre comment personnaliser le `WandbCallback` pour exécuter les prédictions du modèle et journaliser des échantillons d’évaluation dans un tableau W&B pendant l’entraînement. Cela s’exécute tous les `eval_steps` en utilisant la méthode `on_evaluate` du callback du `Trainer`. -Ici, nous avons écrit une fonction `decode_predictions` pour décoder les prédictions et les labels à partir de la sortie du modèle à l’aide du tokenizer. +La fonction `decode_predictions` décode les prédictions et les labels à partir de la sortie du modèle à l’aide du tokenizer. -Ensuite, nous créons un dataframe pandas à partir des prédictions et des labels, puis nous ajoutons une colonne `epoch` au dataframe. +Ensuite, le code crée un dataframe pandas à partir des prédictions et des labels, puis ajoute une colonne `epoch` au dataframe. -Enfin, nous créons un `wandb.Table` à partir du dataframe et le journalisons dans wandb. -De plus, nous pouvons contrôler la fréquence de la journalisation en journalisant les prédictions toutes les `freq` époques. +Enfin, le code crée un `wandb.Table` à partir du dataframe et le journalise dans W&B. Vous pouvez contrôler la fréquence de la journalisation en journalisant les prédictions toutes les `freq` époques. -**Remarque** : contrairement au `WandbCallback` standard, ce callback personnalisé doit être ajouté au trainer **après** l’instanciation du `Trainer`, et non pendant l’initialisation du `Trainer`. -Cela s’explique par le fait que l’instance `Trainer` est transmise au callback lors de l’initialisation. + + Contrairement au `WandbCallback` standard, ce callback personnalisé doit être ajouté au trainer **après** l’instanciation du `Trainer`, et non pendant l’initialisation du `Trainer`. Cela s’explique par le fait que l’instance `Trainer` est transmise au callback lors de l’initialisation. + ```python from transformers.integrations import WandbCallback @@ -460,22 +470,22 @@ progress_callback = WandbPredictionProgressCallback( trainer.add_callback(progress_callback) ``` -Pour un exemple plus détaillé, veuillez vous référer à ce [colab](https://colab.research.google.com/github/wandb/examples/blob/master/colabs/huggingface/Custom_Progress_Callback.ipynb) +Pour un exemple plus détaillé, voir ce [Colab](https://colab.research.google.com/github/wandb/examples/blob/master/colabs/huggingface/Custom_Progress_Callback.ipynb). -
- ### Quels paramètres W&B supplémentaires sont disponibles ? +
+ ### Paramètres W&B supplémentaires
-Vous pouvez affiner la configuration de ce qui est enregistré avec `Trainer` en définissant des variables d'environnement. Une liste complète des variables d'environnement W&B [est disponible ici](/fr/platform/hosting/env-vars). +Vous pouvez affiner la configuration de ce qui est enregistré avec `Trainer` en définissant des variables d'environnement. Pour obtenir une liste complète des variables d'environnement W&B, voir la [référence des variables d'environnement](/fr/platform/hosting/env-vars). | Variable d'environnement | Utilisation | | ---------------------------- | --------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | | `WANDB_PROJECT` | Donnez un nom à votre projet (`huggingface` par défaut) | -| `WANDB_LOG_MODEL` |

Enregistre le point de contrôle du modèle en tant qu'Artifact W&B (`false` par défaut)

  • false (par défaut) : aucun point de contrôle du modèle
  • checkpoint : un point de contrôle sera téléversé tous les args.save_steps (défini dans les TrainingArguments de Trainer).
  • end : le point de contrôle final du modèle sera téléversé à la fin de l'entraînement.
| -| `WANDB_WATCH` |

Définit si vous souhaitez enregistrer, pour vos modèles, les gradients, les paramètres ou aucun des deux

  • false (par défaut) : aucune journalisation des gradients ni des paramètres
  • gradients : enregistre des histogrammes des gradients
  • all : enregistre des histogrammes des gradients et des paramètres
| -| `WANDB_DISABLED` | Définissez `true` pour désactiver complètement la journalisation (`false` par défaut) | -| `WANDB_QUIET`. | Définissez `true` pour limiter la sortie standard aux seuls messages critiques (`false` par défaut) | -| `WANDB_SILENT` | Définissez `true` pour supprimer la sortie affichée par wandb (`false` par défaut) | +| `WANDB_LOG_MODEL` |

Enregistre le point de contrôle du modèle en tant qu'Artifact W&B (`false` par défaut)

  • false (par défaut) : aucun point de contrôle du modèle
  • checkpoint : un point de contrôle sera téléversé tous les `args.save_steps` (défini dans les `TrainingArguments` de Trainer).
  • end : le point de contrôle final du modèle sera téléversé à la fin de l'entraînement.
| +| `WANDB_WATCH` |

Définit si vous souhaitez enregistrer, pour vos modèles, les gradients, les paramètres ou aucun des deux

  • false (par défaut) : aucune journalisation des gradients ni des paramètres
  • gradients : enregistre des histogrammes des gradients
  • all : enregistre des histogrammes des gradients et des paramètres
| +| `WANDB_DISABLED` | Définissez `true` pour désactiver complètement la journalisation (`false` par défaut) | +| `WANDB_QUIET` | Définissez `true` pour limiter la sortie standard aux seuls messages critiques (`false` par défaut) | +| `WANDB_SILENT` | Définissez `true` pour supprimer la sortie affichée par `wandb` (`false` par défaut) | @@ -493,13 +503,13 @@ Vous pouvez affiner la configuration de ce qui est enregistré avec `Trainer` en -
- ### Comment puis-je personnaliser `wandb.init()`? +
+ ### Personnaliser `wandb.init()`
Le `WandbCallback` utilisé par `Trainer` appelle `wandb.init()` en interne lors de l'initialisation de `Trainer`. Vous pouvez aussi configurer vos runs manuellement en appelant `wandb.init()` avant l'initialisation de `Trainer`. Cela vous donne un contrôle total sur la configuration de votre run W&B. -Voici un exemple de ce que vous pouvez passer à `init`. Pour plus de détails sur `wandb.init()`, voir la [`référence \`wandb.init()``](/fr/models/ref/python/functions/init). +Voici un exemple de ce que vous pouvez passer à `init`. Pour plus de détails sur `wandb.init()`, voir la [référence `wandb.init()`](/fr/models/ref/python/functions/init). ```python wandb.init( @@ -514,66 +524,66 @@ wandb.init( ## Ressources supplémentaires
-Voici 6 articles liés à Transformers et à W&B qui pourraient vous intéresser +Pour aller plus loin, voici six articles sur Transformers et W&B.
- Optimisation des hyperparamètres pour Hugging Face Transformers + Optimisation des hyperparamètres pour les Transformers de Hugging Face - * Trois stratégies d'optimisation des hyperparamètres pour Hugging Face Transformers sont comparées : la recherche sur grille, l'optimisation bayésienne et le Population Based Training. - * Nous utilisons un modèle BERT standard en minuscules de Hugging Face Transformers, et nous voulons effectuer un Fine-tuning sur le jeu de données RTE du benchmark SuperGLUE. - * Les résultats montrent que le Population Based Training est l'approche la plus efficace pour optimiser les hyperparamètres de notre modèle Transformer Hugging Face. + * Compare trois stratégies d’optimisation des hyperparamètres pour les Transformers de Hugging Face : recherche sur grille, optimisation bayésienne et entraînement basé sur la population. + * Utilise un modèle BERT standard insensible à la casse de Hugging Face transformers, affiné sur le dataset RTE du benchmark SuperGLUE. + * Les résultats montrent que l’entraînement basé sur la population est l’approche la plus efficace pour optimiser les hyperparamètres du modèle transformer de Hugging Face. - Lisez le [rapport Hyperparameter Optimization for Hugging Face Transformers](https://wandb.ai/amogkam/transformers/reports/Hyperparameter-Optimization-for-Hugging-Face-Transformers--VmlldzoyMTc2ODI). + Lire le [rapport Hyperparameter Optimization for Hugging Face Transformers](https://wandb.ai/amogkam/transformers/reports/Hyperparameter-Optimization-for-Hugging-Face-Transformers--VmlldzoyMTc2ODI).
Hugging Tweets : entraîner un modèle pour générer des tweets - * Dans cet article, l'auteur montre comment effectuer le Fine-tuning d'un modèle Transformer GPT-2 préentraîné de Hugging Face sur les tweets de n'importe quelle personne en cinq minutes. - * Le modèle suit le pipeline suivant : téléchargement des tweets, optimisation du jeu de données, expériences initiales, comparaison des pertes entre Users, Fine-tuning du modèle. + * Dans cet article, l’auteur montre comment effectuer le fine-tuning d’un modèle GPT2 Transformer préentraîné de Hugging Face sur les tweets de n’importe qui en cinq minutes. + * Le modèle suit le pipeline suivant : téléchargement des tweets, optimisation du dataset, expériences initiales, comparaison des pertes entre utilisateurs et fine-tuning du modèle. - Lisez le rapport complet [ici](https://wandb.ai/wandb/huggingtweets/reports/HuggingTweets-Train-a-Model-to-Generate-Tweets--VmlldzoxMTY5MjI). + Lire le [rapport HuggingTweets](https://wandb.ai/wandb/huggingtweets/reports/HuggingTweets-Train-a-Model-to-Generate-Tweets--VmlldzoxMTY5MjI).
- Classification de phrases avec Hugging Face BERT et WB + Classification de phrases avec Hugging Face BERT et W&B - * Dans cet article, nous allons créer un classifieur de phrases en tirant parti des avancées récentes en traitement du langage naturel, en nous concentrant sur une application de l'apprentissage par transfert au NLP. - * Nous utiliserons le jeu de données The Corpus of Linguistic Acceptability (CoLA) pour la classification de phrases isolées. Il s'agit d'un ensemble de phrases étiquetées comme grammaticalement correctes ou incorrectes, publié pour la première fois en mai 2018. - * Nous utiliserons le BERT de Google pour créer des modèles très performants avec un minimum d'effort sur un large éventail de tâches NLP. + * Cet article construit un classificateur de phrases en s’appuyant sur la puissance des avancées récentes en traitement du langage naturel, en mettant l’accent sur une application de l’apprentissage par transfert au NLP. + * Utilise le dataset The Corpus of Linguistic Acceptability (CoLA) pour la classification de phrases isolées, un ensemble de phrases étiquetées comme grammaticalement correctes ou incorrectes, publié pour la première fois en mai 2018. + * Utilise BERT de Google pour créer des modèles hautement performants avec un effort minimal sur un ensemble de tâches de NLP. - Lisez le rapport complet [ici](https://wandb.ai/cayush/bert-finetuning/reports/Sentence-Classification-With-Huggingface-BERT-and-W-B--Vmlldzo4MDMwNA). + Lire le [rapport Sentence Classification With Hugging Face BERT and W&B](https://wandb.ai/cayush/bert-finetuning/reports/Sentence-Classification-With-Huggingface-BERT-and-W-B--Vmlldzo4MDMwNA).
Guide étape par étape pour suivre les performances des modèles Hugging Face - * Nous utilisons W&B et Hugging Face Transformers pour entraîner DistilBERT, un Transformer 40 % plus petit que BERT mais qui conserve 97 % de la précision de BERT, sur le benchmark GLUE. - * Le benchmark GLUE est une collection de neuf jeux de données et tâches pour entraîner des modèles NLP. + * Utilise W&B et Hugging Face transformers pour entraîner DistilBERT, un Transformer 40 % plus petit que BERT mais qui conserve 97 % de la précision de BERT, sur le benchmark GLUE. + * Le benchmark GLUE est une collection de neuf datasets et tâches pour l’entraînement de modèles de NLP. - Lisez le rapport complet [ici](https://wandb.ai/jxmorris12/huggingface-demo/reports/A-Step-by-Step-Guide-to-Tracking-HuggingFace-Model-Performance--VmlldzoxMDE2MTU). + Lire le [rapport Tracking Hugging Face Model Performance](https://wandb.ai/jxmorris12/huggingface-demo/reports/A-Step-by-Step-Guide-to-Tracking-HuggingFace-Model-Performance--VmlldzoxMDE2MTU).
- Exemples d'arrêt anticipé dans HuggingFace + Exemples d’arrêt anticipé avec HuggingFace - * Le Fine-tuning d'un Transformer Hugging Face à l'aide de la régularisation par arrêt anticipé peut être effectué nativement dans PyTorch ou TensorFlow. - * L'utilisation du callback EarlyStopping dans TensorFlow est simple avec le callback `tf.keras.callbacks.EarlyStopping`. - * Dans PyTorch, il n'existe pas de méthode d'arrêt anticipé prête à l'emploi, mais un hook d'arrêt anticipé fonctionnel est disponible dans un GitHub Gist. + * Vous pouvez effectuer le fine-tuning d’un Transformer Hugging Face en utilisant nativement la régularisation par arrêt anticipé dans PyTorch ou TensorFlow. + * Le callback `tf.keras.callbacks.EarlyStopping` rend l’utilisation de EarlyStopping dans TensorFlow particulièrement simple. + * PyTorch ne fournit pas de méthode d’arrêt anticipé prête à l’emploi, mais un hook d’arrêt anticipé fonctionnel est disponible sur GitHub Gist. - Lisez le rapport complet [ici](https://wandb.ai/ayush-thakur/huggingface/reports/Early-Stopping-in-HuggingFace-Examples--Vmlldzo0MzE2MTM). + Lire le [rapport Early Stopping in Hugging Face](https://wandb.ai/ayush-thakur/huggingface/reports/Early-Stopping-in-HuggingFace-Examples--Vmlldzo0MzE2MTM).
- Comment effectuer le Fine-tuning de Hugging Face Transformers sur un jeu de données personnalisé + Comment effectuer le fine-tuning des Transformers de Hugging Face sur un dataset personnalisé - Nous effectuons le Fine-tuning d'un Transformer DistilBERT pour l'analyse de sentiment (classification binaire) sur un jeu de données IMDB personnalisé. + Effectue le fine-tuning d’un modèle DistilBERT pour l’analyse de sentiment (classification binaire) sur un dataset IMDB personnalisé. - Lisez le rapport complet [ici](https://wandb.ai/ayush-thakur/huggingface/reports/How-to-Fine-Tune-HuggingFace-Transformers-on-a-Custom-Dataset--Vmlldzo0MzQ2MDc). + Lire le [rapport Fine-Tune Hugging Face Transformers on a Custom Dataset](https://wandb.ai/ayush-thakur/huggingface/reports/How-to-Fine-Tune-HuggingFace-Transformers-on-a-Custom-Dataset--Vmlldzo0MzQ2MDc).
## Obtenir de l'aide ou suggérer des fonctionnalités
-Pour tout problème, toute question ou toute demande de fonctionnalité concernant l'intégration W&B de Hugging Face, n'hésitez pas à publier dans [ce fil de discussion sur les forums Hugging Face](https://discuss.huggingface.co/t/logging-experiment-tracking-with-w-b/498) ou à ouvrir une issue dans le [dépôt GitHub Transformers](https://github.com/huggingface/transformers) de Hugging Face. \ No newline at end of file +Pour tout problème, toute question ou toute demande de fonctionnalité concernant l'intégration W&B de Hugging Face, publiez dans [ce fil de discussion sur les forums Hugging Face](https://discuss.huggingface.co/t/logging-experiment-tracking-with-w-b/498) ou ouvrez une issue dans le [dépôt GitHub Transformers](https://github.com/huggingface/transformers) de Hugging Face. \ No newline at end of file diff --git a/fr/models/integrations/hydra.mdx b/fr/models/integrations/hydra.mdx index da37965cf0..af03fb17d2 100644 --- a/fr/models/integrations/hydra.mdx +++ b/fr/models/integrations/hydra.mdx @@ -5,13 +5,13 @@ title: Hydra > [Hydra](https://hydra.cc) est un framework Python open source qui simplifie le développement d'applications de recherche et d'autres applications complexes. Sa principale fonctionnalité est de permettre la création dynamique d'une configuration hiérarchique par composition, puis sa surcharge via des fichiers de configuration et la ligne de commande. -Vous pouvez continuer à utiliser Hydra pour gérer la configuration tout en tirant parti de la puissance de W&B. +Cette page montre comment combiner la gestion de configuration basée sur Hydra avec le suivi des expériences de W&B, afin que vous puissiez conserver les configurations composables de Hydra tout en bénéficiant des fonctionnalités de visualisation, d'optimisation des hyperparamètres et de comparaison des runs de W&B. Les sections suivantes couvrent le suivi des métriques, la journalisation des hyperparamètres à partir des configurations Hydra, le dépannage du multiprocessing et l'optimisation des hyperparamètres avec les balayages W&B.
## Suivre les métriques
-Suivez vos métriques normalement avec `wandb.init()` et `wandb.Run.log()`. Ici, `wandb.entity` et `wandb.project` sont définis dans un fichier de configuration Hydra. +Pour envoyer des métriques depuis un run configuré avec Hydra vers W&B, utilisez `wandb.init()` et `wandb.Run.log()` normalement. Dans l’exemple suivant, `wandb.entity` et `wandb.project` sont définis dans un fichier de configuration Hydra afin que la même configuration pilote à la fois Hydra et W&B. ```python import wandb @@ -28,6 +28,8 @@ def run_experiment(cfg): ## Suivre les hyperparamètres
+La journalisation de la configuration de Hydra dans W&B vous permet de voir chaque hyperparamètre à côté des métriques du run, ce qui facilite la comparaison et la reproduction des expériences. + Hydra utilise [OmegaConf](https://omegaconf.readthedocs.io/en/2.1_branch/) comme interface par défaut pour gérer les dictionnaires de configuration. Les objets de configuration OmegaConf (par exemple, `omegaconf.DictConfig`) ne sont pas de simples instances Python de `dict`. `wandb.Run.config` est une propriété en lecture seule, ce qui signifie que `wandb.Run.config = ...` lève une exception `AttributeError` si vous essayez de lui passer un objet de configuration OmegaConf. @@ -60,7 +62,7 @@ def run_experiment(cfg): ## Résoudre les problèmes liés au multiprocessing
-Si votre processus se bloque au démarrage, cela peut être dû à [ce problème connu](/fr/models/track/log/distributed-training). Pour y remédier, essayez de modifier le protocole de multiprocessing de wandb, en ajoutant par exemple un paramètre de configuration supplémentaire à `wandb.init()` comme suit : +Si votre processus ne répond plus au démarrage, cela peut être dû au [problème connu lié au multiprocessing dans l’entraînement distribué](/fr/models/track/log/distributed-training). Pour y remédier, modifiez le protocole de multiprocessing de W&B en ajoutant un paramètre de configuration supplémentaire à `wandb.init()` : ```python wandb.init(settings=wandb.Settings(start_method="thread")) @@ -69,16 +71,16 @@ wandb.init(settings=wandb.Settings(start_method="thread")) ou en définissant une variable d’environnement globale dans votre shell : ```bash -$ export WANDB_START_METHOD=thread +export WANDB_START_METHOD=thread ```
## Optimiser les hyperparamètres
-[W&B Sweeps](/fr/models/sweeps) est une plateforme de recherche d'hyperparamètres très évolutive, qui fournit des insights et des visualisations sur les expériences W&B avec un minimum de code. Sweeps s'intègre parfaitement aux projets Hydra sans nécessiter d'écrire de code. La seule chose requise est un fichier de configuration décrivant, comme d'habitude, les différents paramètres à balayer. +[balayage W&B](/fr/models/sweeps) est une plateforme de recherche d'hyperparamètres qui fournit des insights et des visualisations sur les expériences W&B avec un minimum de code. Sweeps s'intègre aux projets Hydra sans nécessiter de modifier le code. Vous avez seulement besoin d'un fichier de configuration qui décrit les paramètres à balayer. -Un exemple simple de fichier `sweep.yaml` serait : +Le fichier `sweep.yaml` suivant est un exemple : ```yaml program: main.py @@ -103,7 +105,7 @@ Exécutez le balayage : wandb sweep sweep.yaml ``` -W&B crée automatiquement un balayage dans votre projet et renvoie une commande `wandb agent` à exécuter sur chaque machine où vous souhaitez lancer ce balayage. +W&B crée automatiquement un balayage dans votre projet et renvoie une commande `wandb agent`. Exécutez cette commande sur chaque machine où vous souhaitez lancer ce balayage.
### Passer des paramètres non présents dans les valeurs par défaut d’Hydra @@ -111,10 +113,10 @@ W&B crée automatiquement un balayage dans votre projet et renvoie une comma -Hydra prend en charge le passage de paramètres supplémentaires via la ligne de commande qui ne figurent pas dans le fichier de configuration par défaut, en utilisant un `+` avant la commande. Par exemple, vous pouvez passer un paramètre supplémentaire avec une certaine valeur en appelant simplement : +Hydra prend en charge le passage de paramètres supplémentaires via la ligne de commande qui ne figurent pas dans le fichier de configuration par défaut, en utilisant un `+` avant la commande. Par exemple, passez un paramètre supplémentaire avec une valeur donnée en appelant : ```bash -$ python program.py +experiment=some_experiment +python program.py +experiment=some_experiment ``` -Vous ne pouvez pas exécuter de balayage sur de telles configurations `+`, comme on le fait lors de la configuration des [Hydra Expériences](https://hydra.cc/docs/patterns/configuring_experiments/). Pour contourner ce problème, vous pouvez initialiser le paramètre d'expérience avec un fichier vide par défaut, puis utiliser W&B Sweep pour remplacer ces configurations vides à chaque appel. Pour plus d'informations, consultez [ce Reports W&B](https://wandb.ai/adrishd/hydra-example/reports/Configuring-W-B-Projects-with-Hydra--VmlldzoxNTA2MzQw?galleryTag=posts\&utm_source=fully_connected\&utm_medium=blog\&utm_campaign=hydra). +Vous ne pouvez pas exécuter de balayage sur de telles configurations `+`, comme on le fait lors de la configuration des [Hydra Expériences](https://hydra.cc/docs/patterns/configuring_experiments/). Pour contourner ce problème, initialisez le paramètre d'expérience avec un fichier vide par défaut, puis utilisez un W&B Sweep pour remplacer ces configurations vides à chaque appel. Pour plus d'informations, consultez le rapport W&B [Configuring W&B Projects with Hydra](https://wandb.ai/adrishd/hydra-example/reports/Configuring-W-B-Projects-with-Hydra--VmlldzoxNTA2MzQw?galleryTag=posts\&utm_source=fully_connected\&utm_medium=blog\&utm_campaign=hydra). \ No newline at end of file diff --git a/fr/models/integrations/ignite.mdx b/fr/models/integrations/ignite.mdx index 373221c10c..8959f9e334 100644 --- a/fr/models/integrations/ignite.mdx +++ b/fr/models/integrations/ignite.mdx @@ -1,17 +1,23 @@ --- -description: "Intégrez W&B à PyTorch Ignite pour journaliser automatiquement les métriques d'entraînement, les paramètres du modèle et les configurations de l'expérience." +description: "Intégrez W&B à PyTorch Ignite pour consigner automatiquement les métriques d'entraînement, les paramètres du modèle et les configurations d'expérience." title: PyTorch Ignite --- -* Voir les visualisations obtenues dans ce [rapport W&B d'exemple →](https://app.wandb.ai/example-team/pytorch-ignite-example/reports/PyTorch-Ignite-with-W%26B--Vmlldzo0NzkwMg) -* Essayez d'exécuter vous-même le code dans ce [notebook hébergé d'exemple →](https://colab.research.google.com/drive/15e-yGOvboTzXU4pe91Jg-Yr7sae3zBOJ#scrollTo=ztVifsYAmnRr) +Cette page explique comment utiliser le handler W&B avec PyTorch Ignite pour consigner automatiquement les métriques d'entraînement et de validation, les paramètres du modèle et de l'optimiseur, les gradients et les points de contrôle du modèle pendant vos expériences. -Ignite prend en charge un gestionnaire W&B qui permet de journaliser les métriques, les paramètres du modèle et de l'optimiseur, ainsi que les gradients, pendant l'entraînement et la validation. Il peut également être utilisé pour journaliser des points de contrôle du modèle dans le cloud W&B. Cette classe encapsule également le module wandb. Cela signifie que vous pouvez appeler n'importe quelle fonction wandb à l'aide de ce wrapper. Voir des exemples montrant comment enregistrer les paramètres du modèle et les gradients. +Ignite prend en charge un handler W&B pour consigner les métriques, les paramètres du modèle et de l'optimiseur, ainsi que les gradients pendant l'entraînement et la validation. Vous pouvez également l'utiliser pour consigner les points de contrôle du modèle dans le cloud W&B. Cette classe encapsule le SDK Python W&B (`wandb`) ; vous pouvez donc appeler n'importe quelle fonction `wandb` via ce wrapper. Voir des exemples montrant comment enregistrer les paramètres du modèle et les gradients. + +Pour plus de contexte, voir les ressources suivantes : + +* Voir les visualisations obtenues dans cet [exemple de W&B Report](https://app.wandb.ai/example-team/pytorch-ignite-example/reports/PyTorch-Ignite-with-W%26B--Vmlldzo0NzkwMg). +* Essayez d'exécuter vous-même le code dans ce [notebook hébergé d'exemple](https://colab.research.google.com/drive/15e-yGOvboTzXU4pe91Jg-Yr7sae3zBOJ#scrollTo=ztVifsYAmnRr).
## Configuration de base
+L’exemple suivant définit un modèle convolutionnel simple et des chargeurs de données pour MNIST. Les exemples de journalisation qui suivent s’appuient sur ces éléments. + ```python from argparse import ArgumentParser import wandb @@ -59,7 +65,7 @@ def get_data_loaders(train_batch_size, val_batch_size): return train_loader, val_loader ``` -L’utilisation de `WandBLogger` dans ignite suit un processus modulaire. Commencez par créer un objet `WandBLogger`. Attachez-le ensuite à un trainer ou à un evaluator pour journaliser automatiquement les métriques. Cet exemple montre : +L’utilisation de `WandBLogger` dans Ignite suit un processus modulaire. Commencez par créer un objet `WandBLogger`. Attachez-le ensuite à un trainer ou à un evaluator pour consigner automatiquement les métriques. Cet exemple montre : * La journalisation de la perte d’entraînement, attachée à l’objet trainer. * La journalisation de la perte de validation, attachée à l’evaluator. @@ -121,8 +127,9 @@ def run(train_batch_size, val_batch_size, epochs, lr, momentum, log_interval): wandb_logger.watch(model) ``` -Vous pouvez utiliser ignite `EVENTS`, de manière facultative, pour journaliser directement les métriques dans le terminal +Une fois le logger attaché, Ignite envoie automatiquement en continu à votre projet W&B les métriques d’entraînement et de validation, les paramètres de l’optimizer et les gradients du modèle. +Vous pouvez utiliser Ignite `EVENTS`, de manière facultative, pour journaliser directement les métriques dans le terminal. ```python @trainer.on(Events.ITERATION_COMPLETED(every=log_interval)) @@ -177,22 +184,22 @@ if __name__ == "__main__": run(args.batch_size, args.val_batch_size, args.epochs, args.lr, args.momentum, args.log_interval) ``` -Ce code génère ces visualisations :: +Ce code génère les visualisations suivantes : - tableau de bord d'entraînement PyTorch Ignite + Tableau de bord d’entraînement PyTorch Ignite - performances de PyTorch Ignite + Performances de PyTorch Ignite - résultats de l'optimisation des hyperparamètres de PyTorch Ignite + Résultats du réglage des hyperparamètres de PyTorch Ignite - tableau de bord de comparaison des modèles PyTorch Ignite + Tableau de bord de comparaison des modèles PyTorch Ignite -Consultez la [documentation Ignite](https://pytorch.org/ignite/contrib/handlers.html#module-ignite.contrib.handlers.wandb_logger) pour plus de détails. +Se référer à la [documentation Ignite](https://pytorch.org/ignite/contrib/handlers.html#module-ignite.contrib.handlers.wandb_logger) pour plus de détails. \ No newline at end of file diff --git a/fr/models/integrations/keras.mdx b/fr/models/integrations/keras.mdx index 1f78d3ce43..d9752e3a8f 100644 --- a/fr/models/integrations/keras.mdx +++ b/fr/models/integrations/keras.mdx @@ -1,18 +1,18 @@ --- title: Keras -description: "Utilisez les callbacks Keras de W&B pour suivre les expériences, enregistrer des checkpoints de modèles et visualiser les prédictions pendant l'entraînement." +description: "Utilisez les callbacks Keras de W&B pour suivre les expériences, enregistrer des points de contrôle de modèles et visualiser les prédictions pendant l'entraînement." --- import { ColabLink } from '/snippets/fr/_includes/colab-link.mdx'; {/* */} -Utilisez les callbacks Keras pour suivre les expériences, enregistrer les points de contrôle du modèle et visualiser les prédictions du modèle. Les callbacks Keras sont disponibles dans le module `wandb.integration.keras` à partir de la version `0.13.4` du SDK Python. +Utilisez les callbacks Keras de W&B pour suivre les expériences, enregistrer les points de contrôle du modèle et visualiser les prédictions du modèle pendant l'entraînement. Utilisez cette intégration pour ajouter le suivi des expériences et la gestion des versions des modèles à vos flux de travail d'entraînement Keras sans réécrire votre boucle d'entraînement. -L'intégration Keras de W&B fournit les callbacks suivants : +Les callbacks Keras sont disponibles dans le module `wandb.integration.keras` à partir de la version `0.13.4` du SDK Python. L'intégration Keras de W&B fournit les callbacks suivants : * **`WandbMetricsLogger`** : Utilisez ce callback pour le [suivi des expériences](/fr/models/track/). Il enregistre vos métriques d'entraînement et de validation, ainsi que les métriques système, dans W&B. -* **`WandbModelCheckpoint`** : Utilisez ce callback pour enregistrer les points de contrôle de votre modèle dans les [Artifacts](/fr/models/artifacts/) W&B. +* **`WandbModelCheckpoint`** : Utilisez ce callback pour enregistrer les points de contrôle du modèle de votre modèle dans les [Artifacts](/fr/models/artifacts/) W&B. * **`WandbEvalCallback`**: Ce callback de base enregistre les prédictions du modèle dans les [Tables](/fr/models/tables/) W&B pour une visualisation interactive.
@@ -25,14 +25,14 @@ Installez la dernière version de W&B. pip install -U wandb ``` -Pour utiliser l’intégration Keras, importez les classes requises à partir de `wandb.integration.keras` : +Pour utiliser l’intégration Keras, importez les classes requises à partir de `wandb.integration.keras`. ```python import wandb from wandb.integration.keras import WandbMetricsLogger, WandbModelCheckpoint, WandbEvalCallback ``` -Les sections suivantes décrivent en détail chaque fonction de rappel, avec des exemples de code. +Les sections suivantes décrivent en détail chaque callback, avec des exemples de code.
## Suivre les expériences avec `WandbMetricsLogger` @@ -40,9 +40,9 @@ Les sections suivantes décrivent en détail chaque fonction de rappel, avec des -`wandb.integration.keras.WandbMetricsLogger()` enregistre automatiquement le dictionnaire `logs` de Keras, passé en argument aux méthodes de callback telles que `on_epoch_end`, `on_batch_end`, etc. +`wandb.integration.keras.WandbMetricsLogger()` enregistre le dictionnaire `logs` de Keras, passé en argument aux méthodes de callback telles que `on_epoch_end` et `on_batch_end`. -L'exemple partiel ci-dessous montre comment utiliser `WandbMetricsLogger()` dans un flux de travail Keras. Commencez par compiler le modèle avec l'optimiseur, la fonction de perte et les métriques souhaités. Ensuite, initialisez un run W&B à l'aide de `wandb.init()`. Enfin, transmettez le callback `WandbMetricsLogger()` à `model.fit()`. +L'exemple partiel suivant montre comment utiliser `WandbMetricsLogger()` dans un flux de travail Keras. Commencez par compiler le modèle avec l'optimiseur, la fonction de perte et les métriques souhaités. Ensuite, initialisez un run W&B à l'aide de `wandb.init()`. Enfin, transmettez le callback `WandbMetricsLogger()` à `model.fit()`. ```python import wandb @@ -64,7 +64,7 @@ with wandb.init(config={"batch_size": 64}) as run: ) ``` -L’exemple précédent consigne dans W&B les métriques d’entraînement et de validation, telles que `loss`, `accuracy` et `top@5_accuracy`, à la fin de chaque époque. Il consigne également : +L’exemple précédent consigne dans W&B les métriques d’entraînement et de validation, telles que `loss`, `accuracy` et `top@5_accuracy`, à la fin de chaque époque.
### Référence de `WandbMetricsLogger` @@ -126,15 +126,15 @@ with wandb.init(config={"bs": 12}) as run: | `save_best_only` | (Boolean) : si `save_best_only=True`, enregistre uniquement le dernier modèle ou le modèle considéré comme le meilleur, selon les attributs `monitor` et `mode`. | | | `save_weights_only` | (Boolean) : si True, enregistre uniquement les poids du modèle. | | | `mode` | (`auto`, `min` ou `max`) : pour `val_acc`, définissez-le sur `max` ; pour `val_loss`, définissez-le sur `min`, et ainsi de suite. | | -| `save_freq` | ("epoch" ou int) : lorsque vous utilisez `epoch`, le callback enregistre le modèle après chaque époque. Lorsque vous utilisez un entier, le callback enregistre le modèle à la fin de ce nombre de lots. Notez que lors de la surveillance de métriques de validation telles que `val_acc` ou `val_loss`, `save_freq` doit être défini sur "epoch", car ces métriques ne sont disponibles qu'à la fin d'une époque. | | +| `save_freq` | ("epoch" ou int) : lorsque vous utilisez "epoch", le callback enregistre le modèle après chaque époque. Lorsque vous utilisez un entier, le callback enregistre le modèle à la fin de ce nombre de lots. Lors de la surveillance de métriques de validation telles que `val_acc` ou `val_loss`, `save_freq` doit être défini sur "epoch", car ces métriques ne sont disponibles qu'à la fin d'une époque. | | | `options` | (str) : objet `tf.train.CheckpointOptions` facultatif si `save_weights_only` est true, ou objet `tf.saved_model.SaveOptions` facultatif si `save_weights_only` est false. | | | `initial_value_threshold` | (float) : valeur initiale à virgule flottante du « meilleur » résultat de la métrique à surveiller. | |
- ### Enregistrer des checkpoints après N époques + ### Enregistrer des points de contrôle du modèle après `N` époques
-Par défaut (`save_freq="epoch"`), le callback crée un checkpoint et le téléverse comme artifact après chaque époque. Pour créer un checkpoint après un nombre précis de lots, définissez `save_freq` sur un entier. Pour créer un checkpoint après `N` époques, calculez la cardinalité du dataloader `train` et passez-la à `save_freq` : +Par défaut (`save_freq="epoch"`), le callback crée un point de contrôle du modèle et le téléverse comme artifact après chaque époque. Pour créer un point de contrôle du modèle après un nombre précis de lots, définissez `save_freq` sur un entier. Pour créer un point de contrôle du modèle après `N` époques, calculez la cardinalité du dataloader `train` et passez-la à `save_freq` : ```python WandbModelCheckpoint( @@ -143,11 +143,11 @@ WandbModelCheckpoint( ) ``` -
- ### Journaliser efficacement les checkpoints sur une architecture TPU +
+ ### Journaliser efficacement les points de contrôle du modèle sur une architecture TPU
-Lors de la création de checkpoints sur des TPU, vous pouvez rencontrer le message d'erreur `UnimplementedError: File system scheme '[local]' not implemented`. Cela se produit parce que le répertoire du modèle (`filepath`) doit utiliser un chemin de bucket de stockage cloud (`gs://bucket-name/...`), et que ce bucket doit être accessible depuis le serveur TPU. À la place, W&B utilise le chemin local pour créer les checkpoints, qui sont ensuite téléversés en tant qu'artifact. +Lors de la création de points de contrôle du modèle sur des TPU, vous pouvez rencontrer le message d'erreur `UnimplementedError: File system scheme '[local]' not implemented`. Cela se produit parce que le répertoire du modèle (`filepath`) doit utiliser un chemin de bucket de stockage cloud (`gs://bucket-name/...`), et que ce bucket doit être accessible depuis le serveur TPU. À la place, W&B utilise le chemin local pour créer les points de contrôle du modèle, que W&B téléverse ensuite en tant qu'artifact. ```python checkpoint_options = tf.saved_model.SaveOptions(experimental_io_device="/job:localhost") @@ -244,26 +244,26 @@ with wandb.init(config={"hyper": "parameter"}) as run: | `pred_table_columns` | (liste) Liste des noms de colonnes du `pred_table` |
- ### Détails de l'empreinte mémoire + ### Détails de l’empreinte mémoire
-Nous journalisons `data_table` dans W&B lorsque la méthode `on_train_begin` est appelée. Une fois téléversé en tant qu'Artifact W&B, nous obtenons une référence à ce tableau, accessible via la variable de classe `data_table_ref`. `data_table_ref` est une liste 2D qui peut être indexée comme `self.data_table_ref[idx][n]`, où `idx` est le numéro de ligne et `n` le numéro de colonne. Voyons son utilisation dans l'exemple ci-dessous. +W&B journalise `data_table` lors de l’appel de la méthode `on_train_begin`. Après que W&B l’a téléversé en tant qu’artefact W&B, vous obtenez une référence à ce tableau, accessible via la variable de classe `data_table_ref`. `data_table_ref` est une liste 2D que vous pouvez indexer comme `self.data_table_ref[idx][n]`, où `idx` est le numéro de ligne et `n` le numéro de colonne. Voir son utilisation dans l’exemple suivant.
### Personnaliser le callback
-Vous pouvez redéfinir les méthodes `on_train_begin` ou `on_epoch_end` pour bénéficier d’un contrôle plus précis. Si vous souhaitez journaliser les échantillons après `N` lots, vous pouvez implémenter la méthode `on_train_batch_end`. +Pour mieux contrôler quand les données et les prédictions sont enregistrées, vous pouvez redéfinir les méthodes de callback par défaut. Vous pouvez redéfinir les méthodes `on_train_begin` ou `on_epoch_end` pour bénéficier d’un contrôle plus précis. Si vous souhaitez journaliser les échantillons après `N` lots, vous pouvez implémenter la méthode `on_train_batch_end`. - Si vous implémentez un callback pour visualiser les prédictions du modèle en héritant de `WandbEvalCallback` et que certains points doivent être clarifiés ou corrigés, faites-le-nous savoir en ouvrant une [issue](https://github.com/wandb/wandb/issues). + Si vous implémentez un callback pour visualiser les prédictions du modèle en héritant de `WandbEvalCallback` et que certains points doivent être clarifiés ou corrigés, ouvrez une [issue](https://github.com/wandb/wandb/issues). -
- ## `WandbCallback` [obsolète] +
+ ## `WandbCallback` obsolète
-Utilisez la classe `WandbCallback()` de la bibliothèque W&B pour enregistrer automatiquement toutes les métriques et valeurs de perte suivies dans `model.fit()`. +`WandbCallback` est le callback tout-en-un obsolète. Pour les nouveaux projets, utilisez les callbacks dédiés décrits dans les sections précédentes (`WandbMetricsLogger`, `WandbModelCheckpoint` et `WandbEvalCallback`). Utilisez la classe `WandbCallback()` de la bibliothèque W&B pour enregistrer toutes les métriques et valeurs de perte suivies dans `model.fit()`. ```python import wandb @@ -283,20 +283,17 @@ Vous pouvez regarder la courte vidéo [Premiers pas avec Keras et W&B en moi Pour une vidéo plus détaillée, regardez [Intégrer W&B à Keras](https://www.youtube.com/watch?v=Bsudo7jbMow\&ab_channel=Weights%26Biases). Vous pouvez également consulter le [notebook Jupyter Colab](https://colab.research.google.com/github/wandb/examples/blob/master/colabs/keras/Keras_pipeline_with_Weights_and_Biases.ipynb). - - Voir notre [dépôt d'exemples](https://github.com/wandb/examples) pour des scripts, notamment un [exemple Fashion MNIST](https://github.com/wandb/examples/blob/master/examples/keras/keras-cnn-fashion/train.py) - et le [tableau de bord W&B](https://wandb.ai/wandb/keras-fashion-mnist/runs/5z1d85qs) qu'il génère. - +Pour des scripts d'exemple supplémentaires, voir le [dépôt d'exemples W&B](https://github.com/wandb/examples), notamment un [exemple Fashion MNIST](https://github.com/wandb/examples/blob/master/examples/keras/keras-cnn-fashion/train.py) et le [tableau de bord W&B](https://wandb.ai/wandb/keras-fashion-mnist/runs/5z1d85qs) qu'il génère. -La classe `WandbCallback` prend en charge un large éventail d'options de configuration de journalisation : spécifier une métrique à surveiller, suivre les poids et les gradients, journaliser les prédictions sur training_data et validation_data, entre autres. +La classe `WandbCallback` prend en charge des options de configuration de journalisation : spécifier une métrique à surveiller, suivre les poids et les gradients, journaliser les prédictions sur `training_data` et `validation_data`, entre autres. Consultez la documentation de référence de `keras.WandbCallback` pour plus de détails. -Le `WandbCallback` +`WandbCallback` : -* Journalise automatiquement les données d'historique de toutes les métriques collectées par Keras : la perte et tout ce qui est transmis à `keras_model.compile()`. +* Journalise les données d'historique de toutes les métriques collectées par Keras : la perte et tout ce qui est transmis à `keras_model.compile()`. * Définit les métriques de synthèse pour le run associé à la « meilleure » étape d'entraînement, telle que définie par les attributs `monitor` et `mode`. Par défaut, il s'agit de l'époque où `val_loss` est minimale. Par défaut, `WandbCallback` enregistre le modèle associé à la meilleure `epoch`. -* Journalise de façon facultative l'histogramme des gradients et des paramètres. +* Journalise de façon facultative les histogrammes des gradients et des paramètres. * Enregistre de façon facultative les données d'entraînement et de validation pour que wandb puisse les visualiser.
@@ -313,7 +310,7 @@ Le `WandbCallback` | `log_weights` | (booléen) si True, enregistre les histogrammes des poids des couches du modèle. | | `log_gradients` | (booléen) si True, journalise les histogrammes des gradients d’entraînement | | `training_data` | (tuple) Même format `(X,y)` que celui transmis à `model.fit`. Nécessaire pour calculer les gradients ; ce paramètre est obligatoire si `log_gradients` est `True`. | -| `validation_data` | (tuple) Même format `(X,y)` que celui transmis à `model.fit`. Un jeu de données à visualiser par wandb. Si vous définissez ce champ, à chaque époque, wandb effectue un petit nombre de prédictions et enregistre les résultats pour une visualisation ultérieure. | +| `validation_data` | (tuple) Même format `(X,y)` que celui transmis à `model.fit`. Un jeu de données à visualiser par wandb. Si vous définissez ce champ, wandb effectue un petit nombre de prédictions à chaque époque et enregistre les résultats pour une visualisation ultérieure. | | `generator` | (générateur) un générateur qui renvoie des données de validation que wandb peut visualiser. Ce générateur doit renvoyer des tuples `(X,y)`. Vous devez définir `validate_data` ou `generator` pour que wandb puisse visualiser des exemples de données spécifiques. | | `validation_steps` | (int) si `validation_data` est un générateur, nombre d’étapes nécessaires pour exécuter le générateur sur l’ensemble complet de validation. | | `labels` | (liste) Si vous visualisez vos données avec wandb, cette liste d'étiquettes convertit les sorties numériques en chaînes compréhensibles si vous créez un classificateur à plusieurs classes. Pour un classificateur binaire, vous pouvez fournir une liste de deux étiquettes [`label for false`, `label for true`]. Si `validate_data` et `generator` sont tous deux à false, cela n'a aucun effet. | @@ -334,8 +331,8 @@ Le `WandbCallback` ## Questions fréquentes
-
- ### Comment puis-je utiliser le mode multiprocessing de `Keras` avec `wandb` ? +
+ ### Utiliser le mode multiprocessing de `Keras` avec `wandb`
Lorsque vous définissez `use_multiprocessing=True`, cette erreur peut se produire : @@ -347,4 +344,4 @@ Error("You must call wandb.init() before wandb.config.batch_size") Pour contourner ce problème : 1. Lors de l'instanciation de la classe `Sequence`, ajoutez : `wandb.init(group='...')`. -2. Dans `main`, assurez-vous d'utiliser `if __name__ == "__main__":` et placez-y le reste de la logique de votre script. +2. Dans `main`, assurez-vous d'utiliser `if __name__ == "__main__":` et placez-y le reste de la logique de votre script. \ No newline at end of file diff --git a/fr/models/integrations/kubeflow-pipelines-kfp.mdx b/fr/models/integrations/kubeflow-pipelines-kfp.mdx index 61a5b5af2f..a1c30d6ea8 100644 --- a/fr/models/integrations/kubeflow-pipelines-kfp.mdx +++ b/fr/models/integrations/kubeflow-pipelines-kfp.mdx @@ -5,11 +5,11 @@ title: Kubeflow Pipelines (kfp) import ApiKeyCreateStreamlined from "/snippets/fr/_includes/api-key-create-streamlined.mdx"; -[Kubeflow Pipelines (kfp) ](https://www.kubeflow.org/docs/components/pipelines/overview/)est une plateforme permettant de créer et de déployer des flux de travail de machine learning (ML) portables et évolutifs basés sur des conteneurs Docker. +[Kubeflow Pipelines (kfp)](https://www.kubeflow.org/docs/components/pipelines/overview/) est une plateforme permettant de créer et de déployer des flux de travail de machine learning (ML) portables et évolutifs basés sur des conteneurs Docker. -Cette intégration permet aux utilisateurs d’appliquer des décorateurs aux composants fonctionnels Python de kfp afin de journaliser automatiquement les paramètres et les Artifacts dans W&B. +Ce guide vous montre comment intégrer W&B à Kubeflow Pipelines afin que les paramètres et les Artifacts de vos composants de pipeline soient automatiquement suivis dans W&B. À la fin, vous pourrez appliquer un décorateur aux composants fonctionnels Python de kfp pour journaliser les entrées, les sorties et les Artifacts dans W&B sans modifier le corps de chaque composant. -Cette fonctionnalité est disponible à partir de `wandb==0.12.11` et nécessite `kfp<2.0.0` +Cette fonctionnalité est disponible à partir de `wandb==0.12.11` et nécessite `kfp<2.0.0`.
## Inscrivez-vous et créez une clé API @@ -30,7 +30,7 @@ Pour installer la bibliothèque `wandb` localement et vous connecter : - 1. Définissez la [variable d'environnement](/fr/models/track/environment-variables/) `WANDB_API_KEY` avec votre clé API. + 1. Définissez la [variable d'environnement](/fr/models/track/environment-variables/) `WANDB_API_KEY` avec votre clé API. Remplacez les valeurs entre `<>` par les vôtres : ```bash export WANDB_API_KEY= @@ -70,7 +70,7 @@ Pour installer la bibliothèque `wandb` localement et vous connecter : ## Décorez vos composants
-Ajoutez le décorateur `@wandb_log` et créez vos composants comme d'habitude. Cela journalisera automatiquement dans W&B les paramètres d'entrée/sortie et les artifacts chaque fois que vous exécutez votre pipeline. +Avec la bibliothèque `wandb` installée, vous pouvez désormais activer le suivi W&B sur des composants de pipeline individuels. Ajoutez le décorateur `@wandb_log` et créez vos composants comme d'habitude. Cela journalise automatiquement dans W&B les paramètres d'entrée et de sortie ainsi que les artifacts chaque fois que vous exécutez votre pipeline. ```python from kfp import components @@ -89,7 +89,7 @@ add = components.create_component_from_func(add) ## Transmettre des variables d'environnement aux conteneurs
-Vous devrez peut-être transmettre explicitement des [variables d'environnement](/fr/models/track/environment-variables/) à vos conteneurs. Pour une liaison bidirectionnelle, vous devez également définir la variable d'environnement `WANDB_KUBEFLOW_URL` avec l'URL de base de votre instance Kubeflow Pipelines. Par exemple, `https://kubeflow.mysite.com`. +Chaque composant du pipeline s'exécute dans son propre conteneur. Les identifiants d'authentification W&B disponibles sur votre machine locale ne sont donc pas automatiquement transmis au composant. Vous devrez peut-être transmettre explicitement des [variables d'environnement](/fr/models/track/environment-variables/) à vos conteneurs afin que chaque composant puisse s'authentifier auprès de W&B. Pour une liaison bidirectionnelle, vous devez également définir la variable d'environnement `WANDB_KUBEFLOW_URL` avec l'URL de base de votre instance Kubeflow Pipelines. Par exemple, `https://kubeflow.mysite.com`. ```python import os @@ -114,27 +114,29 @@ def example_pipeline(param1: str, param2: int): ```
- ## Accédez à vos données de manière programmatique + ## Accédez à vos données de façon programmatique
-
- ### Via l’UI de Kubeflow Pipelines +Une fois que les exécutions de votre pipeline effectuent la journalisation vers W&B, vous pouvez consulter et récupérer les données suivies de plusieurs façons. Les sections suivantes expliquent comment accéder à vos runs depuis l’interface utilisateur de Kubeflow Pipelines, l’application web W&B et l’API publique de W&B. + +
+ ### interface utilisateur de Kubeflow Pipelines
-Cliquez sur n’importe quel run dans l’UI de Kubeflow Pipelines qui a été enregistré avec W&B. +Cliquez sur n’importe quel run dans l’interface utilisateur de Kubeflow Pipelines qui a été enregistré avec W&B, puis : -* Consultez les détails des entrées et des sorties dans les onglets `Input/Output` et `ML Metadata`. -* Consultez l’application web W&B depuis l’onglet `Visualizations`. +* Consultez les détails des entrées et des sorties dans les onglets **Input/Output** et **ML Metadata**. +* Consultez l’application web W&B depuis l’onglet **Visualizations**. - W&B dans l’UI de Kubeflow + W&B dans l’interface utilisateur de Kubeflow -
- ### Via l’interface de l’application web +
+ ### Interface utilisateur de l’application web W&B
-L’interface de l’application web affiche le même contenu que l’onglet `Visualizations` dans Kubeflow Pipelines, mais avec davantage d’espace. [En savoir plus sur l’interface de l’application web ici](/fr/models/app). +L’interface utilisateur de l’application web affiche le même contenu que l’onglet **Visualizations** dans Kubeflow Pipelines, mais avec davantage d’espace. Pour plus de détails, voir la [documentation de l’application web W&B](/fr/models/app). Détails du run @@ -144,17 +146,17 @@ L’interface de l’application web affiche le même contenu que l’onglet `Vi DAG du pipeline -
- ### Via l’API publique (pour un accès programmatique) +
+ ### API publique
-* Pour un accès programmatique, [voir notre API publique](/fr/models/ref/python/public-api/). +Pour un accès programmatique, [voir l’API publique](/fr/models/ref/python/public-api/).
- ### Correspondance des concepts entre Kubeflow Pipelines et W&B + ## Correspondance des concepts entre Kubeflow Pipelines et W&B
-Voici la correspondance des concepts de Kubeflow Pipelines avec W&B +Le tableau suivant présente la correspondance entre les concepts de Kubeflow Pipelines et W&B. | Kubeflow Pipelines | W&B | Emplacement dans W&B | | ------------------ | --------------------- | --------------------------------------------------- | @@ -167,13 +169,13 @@ Voici la correspondance des concepts de Kubeflow Pipelines avec W&B ## Journalisation granulaire
-Si vous voulez un contrôle plus fin de la journalisation, vous pouvez ajouter quelques appels à `wandb.log()` et `wandb.log_artifact()` dans le composant. +Le décorateur `@wandb_log` gère automatiquement les entrées et les sorties, mais il ne capture pas les valeurs intermédiaires, comme les métriques d'entraînement au fil des époques. Si vous voulez un contrôle plus fin de la journalisation, vous pouvez ajouter des appels à `wandb.log()` et `wandb.log_artifact()` dans le composant.
### Avec des appels explicites à `wandb.log_artifact()`
-Dans l’exemple ci-dessous, nous entraînons un modèle. Le décorateur `@wandb_log` suivra automatiquement les entrées et sorties pertinentes. Si vous souhaitez également journaliser le processus d’entraînement, vous pouvez l’ajouter explicitement comme suit : +Dans l’exemple suivant, vous entraînez un modèle. Le décorateur `@wandb_log` suit automatiquement les entrées et sorties pertinentes. Si vous souhaitez journaliser le processus d’entraînement, vous pouvez l’ajouter explicitement comme suit : ```python @wandb_log @@ -196,10 +198,10 @@ def train_model( ```
- ### Avec les intégrations implicites de wandb + ### Avec les intégrations implicites de `wandb`
-Si vous utilisez une [intégration de framework que nous prenons en charge](/fr/models/integrations), vous pouvez également transmettre directement le callback : +Si vous utilisez une [intégration de framework prise en charge](/fr/models/integrations), vous pouvez également transmettre directement le callback : ```python @wandb_log diff --git a/fr/models/integrations/lightgbm.mdx b/fr/models/integrations/lightgbm.mdx index 337fd3d237..aa0eccc5cc 100644 --- a/fr/models/integrations/lightgbm.mdx +++ b/fr/models/integrations/lightgbm.mdx @@ -7,7 +7,9 @@ import { ColabLink } from '/snippets/fr/_includes/colab-link.mdx'; -La bibliothèque `wandb` inclut un callback spécial pour [LightGBM](https://lightgbm.readthedocs.io/en/latest/). Il est également facile d’utiliser les fonctionnalités de journalisation génériques de W&B pour suivre des expériences à grande échelle, comme les Sweeps d’hyperparamètres. +Le SDK Python de W&B (`wandb`) inclut un callback spécial pour [LightGBM](https://lightgbm.readthedocs.io/en/latest/) qui journalise automatiquement les métriques d’entraînement, l’importance des variables et les points de contrôle du modèle dans W&B. Vous pouvez également utiliser les fonctionnalités de journalisation génériques de W&B pour suivre des expériences à grande échelle, telles que les Sweeps d’hyperparamètres. + +Utilisez cette intégration pour surveiller les performances des modèles de boosting par gradient, comparer les runs et analyser la contribution des variables sans écrire de code de journalisation personnalisé. ```python from wandb.integration.lightgbm import wandb_callback, log_summary @@ -21,16 +23,16 @@ log_summary(gbm, save_model_checkpoint=True) ``` - Vous cherchez des exemples de code prêts à l’emploi ? Consultez [notre dépôt d’exemples sur GitHub](https://github.com/wandb/examples/tree/master/examples/boosting-algorithms). + Pour des exemples de code prêts à l’emploi, consultez [notre dépôt d’exemples sur GitHub](https://github.com/wandb/examples/tree/master/examples/boosting-algorithms). -
+
## Ajustez vos hyperparamètres avec Sweeps
-Pour tirer le maximum de performances des modèles, vous devez ajuster les hyperparamètres, comme la profondeur des arbres et le taux d’apprentissage. W&B [Sweeps](/fr/models/sweeps/) est une boîte à outils puissante pour configurer, orchestrer et analyser de vastes expériences d’hyperparamétrage. +Pour obtenir les meilleures performances des modèles, ajustez les hyperparamètres, comme la profondeur des arbres et le taux d’apprentissage. W&B [Sweeps](/fr/models/sweeps/) est une boîte à outils qui configure, orchestre et analyse de vastes expériences de test d’hyperparamètres. -Pour en savoir plus sur ces outils et voir un exemple d’utilisation de Sweeps avec XGBoost, consultez ce notebook Colab interactif. +Pour en savoir plus sur ces outils et voir un exemple d’utilisation de Sweeps avec XGBoost, ouvrez le notebook Colab interactif suivant. diff --git a/fr/models/integrations/lightning.mdx b/fr/models/integrations/lightning.mdx index a281e1e86f..92d333bc0e 100644 --- a/fr/models/integrations/lightning.mdx +++ b/fr/models/integrations/lightning.mdx @@ -10,12 +10,16 @@ import ApiKeyCreateStreamlined from "/snippets/fr/_includes/api-key-create-strea {/* */} -PyTorch Lightning fournit un wrapper léger pour organiser votre code PyTorch et ajouter facilement des fonctionnalités avancées telles que l’entraînement distribué et la précision en 16 bits. W&B fournit un wrapper léger pour consigner vos expériences de ML. Mais vous n’avez pas besoin de combiner les deux vous-même : W&B est directement intégré à la bibliothèque PyTorch Lightning via le [`WandbLogger`](https://lightning.ai/docs/pytorch/stable/api/lightning.pytorch.loggers.wandb.html#module-lightning.pytorch.loggers.wandb). +PyTorch Lightning fournit un wrapper léger pour organiser votre code PyTorch et ajouter des fonctionnalités avancées telles que l’entraînement distribué et la précision en 16 bits. W&B fournit un wrapper léger pour consigner vos expériences de ML. Vous n’avez pas besoin de combiner les deux vous-même : la bibliothèque PyTorch Lightning inclut directement W&B via le [`WandbLogger`](https://lightning.ai/docs/pytorch/stable/api/lightning.pytorch.loggers.wandb.html#module-lightning.pytorch.loggers.wandb). + +Cette page explique comment utiliser `WandbLogger` pour suivre les métriques, consigner les hyperparamètres, enregistrer des points de contrôle du modèle comme artifacts, consigner des médias et exécuter un entraînement multi-GPU avec PyTorch Lightning et W&B.
## Intégrer Lightning
+Les sections suivantes montrent comment vous authentifier auprès de W&B, installer la bibliothèque `wandb` et joindre un `WandbLogger` à votre instance Lightning `Trainer` ou `Fabric`. + ```python @@ -24,11 +28,10 @@ PyTorch Lightning fournit un wrapper léger pour organiser votre code PyTorch et wandb_logger = WandbLogger(log_model="all") trainer = Trainer(logger=wandb_logger) - ``` - **Utilisation de wandb.log() :** Le `WandbLogger` envoie les journaux vers W&B en utilisant le `global_step` du Trainer. Si vous effectuez des appels supplémentaires à `wandb.log()` directement dans votre code, **n'utilisez pas** l'argument `step` dans `wandb.log()`. + **Utilisation de `wandb.log()` :** Le `WandbLogger` envoie les journaux vers W&B en utilisant le `global_step` du Trainer. Si vous effectuez des appels supplémentaires à `wandb.log()` directement dans votre code, n'utilisez pas l'argument `step` dans `wandb.log()`. À la place, journalisez le `global_step` du Trainer comme vos autres métriques : @@ -47,7 +50,6 @@ PyTorch Lightning fournit un wrapper léger pour organiser votre code PyTorch et fabric = L.Fabric(loggers=[wandb_logger]) fabric.launch() fabric.log_dict({"important_metric": important_metric}) - ``` @@ -56,9 +58,6 @@ PyTorch Lightning fournit un wrapper léger pour organiser votre code PyTorch et Tableaux de bord interactifs -``` -``` -
### Inscrivez-vous et créez une clé API
@@ -67,6 +66,8 @@ Une clé API permet d’authentifier votre machine auprès de W&B. Vous pouv +Pour générer une clé API depuis votre profil : + 1. Cliquez sur l’icône de votre profil en haut à droite. 2. Sélectionnez **Paramètres utilisateur**, puis faites défiler jusqu’à la section **Clés API**. @@ -78,7 +79,7 @@ Pour installer la bibliothèque `wandb` localement et vous connecter : - 1. Définissez la [variable d'environnement](/fr/models/track/environment-variables/) `WANDB_API_KEY` sur votre clé API. + 1. Définissez la [variable d'environnement](/fr/models/track/environment-variables/) `WANDB_API_KEY` sur votre clé API. Remplacez les valeurs entre `<>` par les vôtres : ```bash export WANDB_API_KEY= @@ -118,7 +119,7 @@ Pour installer la bibliothèque `wandb` localement et vous connecter : ## Utiliser le `WandbLogger` de PyTorch Lightning
-PyTorch Lightning propose plusieurs classes `WandbLogger` pour consigner des métriques, ainsi que les poids du modèle, des médias, et bien plus encore. +PyTorch Lightning propose plusieurs classes `WandbLogger` pour consigner des métriques, ainsi que les poids du modèle et des médias. Choisissez la classe qui correspond à votre configuration d’entraînement : * [`PyTorch`](https://lightning.ai/docs/pytorch/stable/api/lightning.pytorch.loggers.wandb.html#module-lightning.pytorch.loggers.wandb) * [`Fabric`](https://lightning.ai/docs/pytorch/stable/api/lightning.pytorch.loggers.wandb.html#module-lightning.pytorch.loggers.wandb) @@ -147,15 +148,15 @@ Pour l’utiliser avec Lightning, instanciez `WandbLogger`, puis transmettez-le ### Arguments courants du logger
-Vous trouverez ci-dessous quelques-uns des paramètres les plus utilisés dans `WandbLogger`. Consultez la documentation de PyTorch Lightning pour en savoir plus sur tous les arguments du logger. +Le tableau suivant répertorie les paramètres courants de `WandbLogger`. Consultez la documentation de PyTorch Lightning pour en savoir plus sur tous les arguments du logger. * [`PyTorch`](https://lightning.ai/docs/pytorch/stable/api/lightning.pytorch.loggers.wandb.html#module-lightning.pytorch.loggers.wandb) * [`Fabric`](https://lightning.ai/docs/pytorch/stable/api/lightning.pytorch.loggers.wandb.html#module-lightning.pytorch.loggers.wandb) | Paramètre | Description | | ----------- | ------------------------------------------------------------------------------------------------------- | -| `project` | Définit dans quel projet wandb journaliser | -| `name` | Donne un nom à votre run wandb | +| `project` | Définit dans quel projet W&B journaliser | +| `name` | Donne un nom à votre run W&B | | `log_model` | Journalise tous les modèles si `log_model="all"`, ou à la fin de l'entraînement si `log_model=True` | | `save_dir` | Chemin où les données sont enregistrées | @@ -163,6 +164,8 @@ Vous trouverez ci-dessous quelques-uns des paramètres les plus utilisés dans ` ## Journalisez vos hyperparamètres
+La journalisation des hyperparamètres avec W&B vous permet de comparer les runs et de reproduire les résultats. Utilisez la méthode correspondante à votre logger : + ```python @@ -188,6 +191,8 @@ Vous trouverez ci-dessous quelques-uns des paramètres les plus utilisés dans ` ## Journaliser des paramètres de configuration supplémentaires
+Pour capturer des valeurs de configuration supplémentaires en plus de vos hyperparamètres, mettez directement à jour la configuration du run : + ```python # ajouter un paramètre wandb_logger.experiment.config["key"] = value @@ -204,7 +209,7 @@ wandb.config.update() ## Journaliser les gradients, l’histogramme des paramètres et la topologie du modèle
-Vous pouvez passer l’objet de votre modèle à `wandblogger.watch()` pour surveiller les gradients et les paramètres de votre modèle pendant l’entraînement. Voir la documentation de `WandbLogger` pour PyTorch Lightning +Passez l’objet de votre modèle à `wandb_logger.watch()` pour surveiller les gradients et les paramètres de votre modèle pendant l’entraînement. Voir la documentation de `WandbLogger` pour PyTorch Lightning.
## Journaliser des métriques @@ -212,9 +217,9 @@ Vous pouvez passer l’objet de votre modèle à `wandblogger.watch()` pour surv - Vous pouvez journaliser vos métriques dans W&B lorsque vous utilisez `WandbLogger` en appelant `self.log('my_metric_name', metric_vale)` dans votre `LightningModule`, par exemple dans les méthodes `training_step` ou `validation_step`. + Pour journaliser vos métriques dans W&B lorsque vous utilisez `WandbLogger`, appelez `self.log('my_metric_name', metric_value)` dans votre `LightningModule`, par exemple dans les méthodes `training_step` ou `validation_step`. - L’extrait de code ci-dessous montre comment définir votre `LightningModule` pour journaliser vos métriques ainsi que les hyperparamètres de votre `LightningModule`. Cet exemple utilise la bibliothèque [`torchmetrics`](https://github.com/Lightning-AI/torchmetrics) pour calculer vos métriques. + L’extrait de code suivant montre comment définir votre `LightningModule` pour journaliser vos métriques ainsi que les hyperparamètres de votre `LightningModule`. Cet exemple utilise la bibliothèque [`torchmetrics`](https://github.com/Lightning-AI/torchmetrics) pour calculer vos métriques. ```python import torch @@ -247,7 +252,7 @@ Vous pouvez passer l’objet de votre modèle à `wandblogger.watch()` pour surv batch_size, channels, width, height = x.size() x = x.view(batch_size, -1) - # effectuons 3 x (linear + relu) + # appliquer 3 x (linear + relu) x = F.relu(self.layer_1(x)) x = F.relu(self.layer_2(x)) x = self.layer_3(x) @@ -302,32 +307,28 @@ Vous pouvez passer l’objet de votre modèle à `wandblogger.watch()` pour surv model, optimizer = fabric.setup(model, optimizer) train_dataloader = fabric.setup_dataloaders( - torch.utils.data.DataLoader(train_dataset, batch_size=batch_size) + torch.utils.data.DataLoader(train_dataset, batch_size=batch_size) ) model.train() for epoch in range(num_epochs): - for batch in train_dataloader: - optimizer.zero_grad() - loss = model(batch) - loss.backward() - optimizer.step() - fabric.log_dict({"loss": loss}) - + for batch in train_dataloader: + optimizer.zero_grad() + loss = model(batch) + loss.backward() + optimizer.step() + fabric.log_dict({"loss": loss}) ``` -``` -``` -
## Journaliser les valeurs min/max d’une métrique
-Avec la fonction [`define_metric`](/fr/models/ref/python/experiments/run#define_metric) de wandb, vous pouvez définir si vous souhaitez que votre métrique de synthèse W&B affiche la valeur minimale, maximale, moyenne ou la meilleure valeur pour cette métrique. Si `define`_`metric` _ n’est pas utilisé, la dernière valeur journalisée apparaîtra dans vos métriques de synthèse. Voir la [documentation de référence de `define_metric` ici](/fr/models/ref/python/experiments/run#define_metric) et le [guide ici](/fr/models/track/log/customize-logging-axes/) pour en savoir plus. +Avec la fonction [`define_metric`](/fr/models/ref/python/experiments/run#define_metric) de W&B, vous pouvez définir si votre métrique de synthèse W&B affiche la valeur minimale, maximale, moyenne ou la meilleure valeur pour cette métrique. Si `define_metric` n’est pas utilisé, la dernière valeur enregistrée apparaît dans vos métriques de synthèse. Pour plus d'informations, voir le [guide de personnalisation des axes de journalisation](/fr/models/track/log/customize-logging-axes/). -Pour indiquer à W&B de suivre la précision de validation maximale dans la métrique de synthèse W&B, appelez `wandb.define_metric()` une seule fois, au début de l’entraînement : +Pour suivre la précision de validation maximale dans la métrique de synthèse W&B, appelez `wandb.define_metric()` une seule fois, au début de l’entraînement : @@ -345,7 +346,6 @@ Pour indiquer à W&B de suivre la précision de validation maximale dans la self.log("val_loss", loss) self.log("val_accuracy", acc) return preds - ``` @@ -360,9 +360,11 @@ Pour indiquer à W&B de suivre la précision de validation maximale dans la
- ## Créer un point de contrôle d’un modèle + ## Créer un point de contrôle du modèle
+L’enregistrement de points de contrôle du modèle en tant qu’artifacts W&B vous fournit des fichiers de modèle versionnés que vous pourrez récupérer ultérieurement par run, alias ou version. + Pour enregistrer des points de contrôle du modèle en tant qu’Artifacts W&B [Artifacts](/fr/models/artifacts/), utilisez le callback Lightning [`ModelCheckpoint`](https://lightning.ai/docs/pytorch/stable/api/lightning.pytorch.callbacks.ModelCheckpoint.html) et définissez l’argument `log_model` dans `WandbLogger`. @@ -380,25 +382,25 @@ utilisez le callback Lightning [`ModelCheckpoint`](https://lightning.ai/docs/pyt -Les alias *latest* et *best* sont automatiquement définis pour vous permettre de récupérer facilement un point de contrôle du modèle depuis un [Artifact](/fr/models/artifacts/) W&B : +Les alias `latest` et `best` sont définis automatiquement pour vous permettre de récupérer facilement un point de contrôle du modèle depuis un artifact W&B : ```python # la référence peut être récupérée dans le panneau des artifacts -# "VERSION" peut être une version (ex : "v2") ou un alias ("latest" ou "best") -checkpoint_reference = "USER/PROJECT/MODEL-RUN_ID:VERSION" +# peut être une version (par exemple, "v2") ou un alias ("latest" ou "best") +checkpoint_reference = "//:" ``` ```python - # télécharger le point de contrôle en local (s'il n'est pas déjà en cache) + # télécharger le point de contrôle du modèle en local (s'il n'est pas déjà en cache) wandb_logger.download_artifact(checkpoint_reference, artifact_type="model") ``` ```python - # télécharger le point de contrôle en local (s'il n'est pas déjà en cache) + # télécharger le point de contrôle du modèle en local (s'il n'est pas déjà en cache) run = wandb.init(project="MNIST") artifact = run.use_artifact(checkpoint_reference, type="model") artifact_dir = artifact.download() @@ -409,14 +411,14 @@ checkpoint_reference = "USER/PROJECT/MODEL-RUN_ID:VERSION" ```python - # charger le point de contrôle + # charger le point de contrôle du modèle model = LitModule.load_from_checkpoint(Path(artifact_dir) / "model.ckpt") ``` ```python - # récupérer le point de contrôle brut + # récupérer le point de contrôle du modèle brut full_checkpoint = fabric.load(Path(artifact_dir) / "model.ckpt") model.load_state_dict(full_checkpoint["model"]) @@ -425,11 +427,11 @@ checkpoint_reference = "USER/PROJECT/MODEL-RUN_ID:VERSION" -Les points de contrôle de modèle que vous journalisez sont visibles dans l'UI [W&B Artifacts](/fr/models/artifacts/) et incluent la traçabilité complète du modèle (voir un exemple de point de contrôle de modèle dans l'UI [ici](https://wandb.ai/wandb/arttest/artifacts/model/iv3_trained/5334ab69740f9dda4fed/lineage?_gl=1*yyql5q*_ga*MTQxOTYyNzExOS4xNjg0NDYyNzk1*_ga_JH1SJHJQXJ*MTY5MjMwNzI2Mi4yNjkuMS4xNjkyMzA5NjM2LjM3LjAuMA..)). +Les points de contrôle du modèle que vous journalisez sont visibles dans l'UI [W&B Artifacts](/fr/models/artifacts/) et incluent la traçabilité complète du modèle (voir un [exemple de point de contrôle du modèle dans l'UI](https://wandb.ai/wandb/arttest/artifacts/model/iv3_trained/5334ab69740f9dda4fed/lineage?_gl=1*yyql5q*_ga*MTQxOTYyNzExOS4xNjg0NDYyNzk1*_ga_JH1SJHJQXJ*MTY5MjMwNzI2Mi4yNjkuMS4xNjkyMzA5NjM2LjM3LjAuMA..)). -Pour mettre vos meilleurs points de contrôle de modèle en favoris et les centraliser pour votre équipe, vous pouvez les lier au [registre de modèles W&B](/fr/models). +Pour mettre vos meilleurs points de contrôle du modèle en favoris et les centraliser pour votre équipe, liez-les au [registre de modèles W&B](/fr/models). -Vous pouvez y organiser vos meilleurs modèles par tâche, gérer le cycle de vie des modèles, faciliter leur suivi et leur audit tout au long du cycle de vie du ML, et [automatiser](/fr/models/automations/) les actions en aval avec des webhooks ou des jobs. +Dans le registre, vous pouvez organiser vos meilleurs modèles par tâche, gérer le cycle de vie des modèles, faciliter leur suivi et leur audit tout au long du cycle de vie du ML, et [automatiser](/fr/models/automations/) les actions en aval avec des webhooks ou des jobs.
## Journaliser des images, du texte et plus encore @@ -437,7 +439,7 @@ Vous pouvez y organiser vos meilleurs modèles par tâche, gérer le cycle de vi Le `WandbLogger` fournit les méthodes `log_image`, `log_text` et `log_table` pour la journalisation de médias. -Vous pouvez aussi appeler directement `wandb.log()` ou `trainer.logger.experiment.log()` pour journaliser d'autres types de médias, comme Audio, des molécules, des nuages de points, des objets 3D, et bien plus encore. +Vous pouvez aussi appeler directement `wandb.log()` ou `trainer.logger.experiment.log()` pour journaliser d'autres types de médias, comme Audio, des molécules, des nuages de points et des objets 3D. @@ -446,20 +448,16 @@ Vous pouvez aussi appeler directement `wandb.log()` ou `trainer.logger.experimen wandb_logger.log_image(key="samples", images=[img1, img2]) # ajouter des légendes - wandb_logger.log_image(key="samples", images=[img1, img2], caption=["tree", "person"]) # utiliser un chemin de fichier - wandb_logger.log_image(key="samples", images=["img_1.jpg", "img_2.jpg"]) # utiliser .log dans le trainer - trainer.logger.experiment.log( - {"samples": [wandb.Image(img, caption=caption) for (img, caption) in my_images]}, - step=current_trainer_global_step, + {"samples": [wandb.Image(img, caption=caption) for (img, caption) in my_images]}, + step=current_trainer_global_step, ) - ``` @@ -483,21 +481,18 @@ Vous pouvez aussi appeler directement `wandb.log()` ou `trainer.logger.experimen columns = ["caption", "image", "sound"] # les données doivent être une liste de listes - my_data = [ - ["cheese", wandb.Image(img_1), wandb.Audio(snd_1)], - ["wine", wandb.Image(img_2), wandb.Audio(snd_2)], + ["cheese", wandb.Image(img_1), wandb.Audio(snd_1)], + ["wine", wandb.Image(img_2), wandb.Audio(snd_2)], ] # journaliser le tableau - wandb_logger.log_table(key="my_samples", columns=columns, data=my_data) - ``` -Vous pouvez utiliser le système de callbacks de Lightning pour contrôler quand vous journalisez vers W&B via `WandbLogger` ; dans cet exemple, nous journalisons un échantillon de nos images de validation et de nos prédictions : +Utilisez le système de callbacks de Lightning pour contrôler quand vous journalisez vers W&B via le `WandbLogger`. L'exemple suivant journalise un échantillon d'images de validation et de prédictions : ```python import torch @@ -505,7 +500,7 @@ import wandb import lightning.pytorch as pl from lightning.pytorch.loggers import WandbLogger -# ou +# or # from wandb.integration.lightning.fabric import WandbLogger @@ -515,10 +510,10 @@ class LogPredictionSamplesCallback(Callback): ): """Called when the validation batch ends.""" - # `outputs` provient de `LightningModule.validation_step` - # ce qui correspond aux prédictions de notre modèle dans ce cas + # `outputs` comes from `LightningModule.validation_step` + # which corresponds to our model predictions in this case - # Journalisons 20 exemples de prédictions d'images du premier batch + # Journaliser 20 exemples de prédictions d'images du premier batch if batch_idx == 0: n = 20 x, y = batch @@ -528,10 +523,10 @@ class LogPredictionSamplesCallback(Callback): for y_i, y_pred in zip(y[:n], outputs[:n]) ] - # Option 1 : journaliser les images avec `WandbLogger.log_image` + # Option 1: log images with `WandbLogger.log_image` wandb_logger.log_image(key="sample_images", images=images, caption=captions) - # Option 2 : journaliser les images et les prédictions sous forme de W&B Table + # Option 2: log images and predictions as a W&B Table columns = ["image", "ground truth", "prediction"] data = [ [wandb.Image(x_i), y_i, y_pred] or x_i, @@ -548,9 +543,11 @@ trainer = pl.Trainer(callbacks=[LogPredictionSamplesCallback()]) ## Utiliser plusieurs GPU avec Lightning et W&B
+Lorsque vous exécutez un entraînement distribué, la manière dont vous référencez `wandb.run` d’un rang à l’autre peut déterminer si l’entraînement se poursuit ou s’il entre en interblocage. Cette section explique les exigences et présente un modèle recommandé. + PyTorch Lightning prend en charge le multi-GPU via son interface DDP. Cependant, la conception de PyTorch Lightning exige que vous fassiez attention à la façon dont vous instanciez vos GPU. -Lightning part du principe que chaque GPU (ou rang) dans votre boucle d’entraînement doit être instancié exactement de la même manière, avec les mêmes conditions initiales. Cependant, seul le processus de rang 0 a accès à l’objet `wandb.run`, et pour les processus de rang non nul : `wandb.run = None`. Cela peut faire échouer vos processus non nuls. Une telle situation peut vous placer dans un **interblocage**, car le processus de rang 0 attendra que les processus de rang non nul le rejoignent, alors qu’ils ont déjà planté. +Lightning exige que chaque GPU (ou rang) dans votre boucle d’entraînement soit instancié exactement de la même manière, avec les mêmes conditions initiales. Cependant, seul le processus de rang 0 a accès à l’objet `wandb.run`. Pour les processus de rang non nul, `wandb.run = None`. Cela peut faire échouer vos processus non nuls. Une telle situation peut vous placer dans un interblocage, car le processus de rang 0 attend que les processus de rang non nul le rejoignent, alors qu’ils ont déjà planté. Pour cette raison, faites attention à la façon dont vous configurez votre code d’entraînement. La méthode recommandée consiste à rendre votre code indépendant de l’objet `wandb.run`. @@ -603,7 +600,7 @@ def main(): val_loader = DataLoader(val_dataset, batch_size=64, shuffle=False, num_workers=4) model = MNISTClassifier() - wandb_logger = WandbLogger(project="") + wandb_logger = WandbLogger(project="") callbacks = [ ModelCheckpoint( dirpath="checkpoints", @@ -620,7 +617,7 @@ def main(): ## Exemples
-Vous pouvez suivre ce tutoriel dans une [vidéo avec un notebook Colab](https://wandb.me/lit-colab). +Pour un guide pas à pas complet, vous pouvez suivre ce tutoriel dans une [vidéo avec un notebook Colab](https://wandb.me/lit-colab).
## Foire aux questions @@ -630,13 +627,13 @@ Vous pouvez suivre ce tutoriel dans une [vidéo avec un notebook Colab](https:// ### Comment W&B s’intègre-t-il à Lightning ?
-L’intégration principale s’appuie sur l’API [Lightning `loggers`](https://lightning.ai/docs/pytorch/stable/extensions/logging.html), qui vous permet d’écrire une grande partie de votre code de journalisation de manière indépendante du framework. Les `Logger` sont transmis au [Lightning `Trainer`](https://lightning.ai/docs/pytorch/stable/common/trainer.html) et sont déclenchés par le riche [système de hooks et de callbacks](https://lightning.ai/docs/pytorch/stable/extensions/callbacks.html) de cette API. Cela permet de bien séparer votre code de recherche du code d’ingénierie et de journalisation. +L’intégration principale s’appuie sur l’API [Lightning `loggers`](https://lightning.ai/docs/pytorch/stable/extensions/logging.html), qui vous permet d’écrire une grande partie de votre code de journalisation de manière indépendante du framework. Les instances de `Logger` sont transmises au [Lightning `Trainer`](https://lightning.ai/docs/pytorch/stable/common/trainer.html) et sont déclenchées par le riche [système de hooks et de callbacks](https://lightning.ai/docs/pytorch/stable/extensions/callbacks.html) de cette API. Cela permet de bien séparer votre code de recherche du code d’ingénierie et de journalisation.
- ### Que journalise l’intégration sans code supplémentaire ? + ### Que l’intégration enregistre-t-elle sans code supplémentaire ?
-Nous enregistrerons les points de contrôle du modèle dans W&B, où vous pourrez les consulter ou les télécharger pour les utiliser dans de futurs runs. Nous capturerons également les [métriques système](/fr/models/ref/python/experiments/system-metrics), comme l’utilisation du GPU et les entrées/sorties réseau, des informations sur l’environnement, comme les caractéristiques du matériel et du système d’exploitation, l’[état du code](/fr/models/app/features/panels/code/) (y compris le commit git et le patch diff, le contenu du notebook et l’historique de la session), ainsi que tout ce qui est affiché dans la sortie standard. +W&B enregistre vos points de contrôle du modèle, que vous pouvez consulter ou télécharger pour les utiliser dans de futures exécutions. W&B capture également les [métriques système](/fr/models/ref/python/experiments/system-metrics), comme l’utilisation du GPU et les E/S réseau. Il capture des informations sur l’environnement, telles que les informations sur le matériel et le système d’exploitation. Il capture l’[état du code](/fr/models/app/features/panels/code/), y compris le commit Git et le patch de diff, le contenu du notebook et l’historique de session. Il capture également tout ce qui est affiché sur la sortie standard.
### Que faire si j’ai besoin d’utiliser `wandb.run` dans ma configuration d’entraînement ? diff --git a/fr/models/integrations/metaflow.mdx b/fr/models/integrations/metaflow.mdx index 85e87defdb..5549e352ad 100644 --- a/fr/models/integrations/metaflow.mdx +++ b/fr/models/integrations/metaflow.mdx @@ -11,15 +11,17 @@ import ApiKeyCreateStreamlined from "/snippets/fr/_includes/api-key-create-strea [Metaflow](https://docs.metaflow.org) est un framework créé par Netflix pour créer et exécuter des flux de travail de ML. -Cette intégration permet aux utilisateurs d’appliquer des décorateurs aux [étapes et flows](https://docs.metaflow.org/metaflow/basics) Metaflow afin d’enregistrer automatiquement les paramètres et les artifacts dans W&B. +Cette intégration vous permet d’appliquer des décorateurs aux [étapes et flows](https://docs.metaflow.org/metaflow/basics) Metaflow afin d’enregistrer automatiquement les paramètres et les artefacts dans W&B, afin que vous puissiez suivre les expériences et inspecter la traçabilité dans l’ensemble des flux de travail que vous créez avec Metaflow sans écrire de code de journalisation personnalisé : -* Décorer une étape permet d’activer ou de désactiver l’enregistrement pour certains types au sein de cette étape. -* Décorer le flow permet d’activer ou de désactiver l’enregistrement pour chaque étape du flow. +* Décorer une étape permet d’activer ou de désactiver la journalisation pour certains types au sein de cette étape. +* Décorer le flow permet d’activer ou de désactiver la journalisation pour chaque étape du flow.
## Démarrage rapide
+Les sections suivantes expliquent comment vous authentifier auprès de W&B, installer les bibliothèques requises et ajouter le décorateur `wandb_log` à vos étapes et flows Metaflow. +
### Inscrivez-vous et créez une clé API
@@ -28,6 +30,8 @@ Une clé API authentifie votre machine auprès de W&B. Vous pouvez générer +Pour trouver votre clé API dans W&B App : + 1. Cliquez sur l’icône de votre profil en haut à droite. 2. Sélectionnez **Paramètres utilisateur**, puis faites défiler jusqu’à la section **API Keys**. @@ -43,7 +47,7 @@ Pour installer la bibliothèque `wandb` en local et vous connecter : - 1. Définissez la [variable d'environnement](/fr/models/track/environment-variables/) `WANDB_API_KEY` sur votre clé API. + 1. Définissez la [variable d'environnement](/fr/models/track/environment-variables/) `WANDB_API_KEY` avec votre clé API. Remplacez les valeurs entre `<>` par les vôtres : ```bash export WANDB_API_KEY= @@ -51,7 +55,7 @@ Pour installer la bibliothèque `wandb` en local et vous connecter : 2. Installez la bibliothèque `wandb` et connectez-vous. - ```shell + ```bash pip install -Uqqq metaflow "plum-dispatch<3.0.0" wandb wandb login @@ -69,8 +73,8 @@ Pour installer la bibliothèque `wandb` en local et vous connecter : ``` - - ```notebook + + ```python !pip install -Uqqq metaflow "plum-dispatch<3.0.0" wandb import wandb @@ -87,7 +91,7 @@ Pour installer la bibliothèque `wandb` en local et vous connecter : Décorer une étape permet d’activer ou de désactiver la journalisation pour certains types au sein de cette étape. - Dans cet exemple, tous les datasets et modèles dans `start` seront enregistrés. + Dans cet exemple, l’intégration journalise tous les datasets et modèles dans `start` : ```python from wandb.integration.metaflow import wandb_log @@ -161,7 +165,7 @@ Pour installer la bibliothèque `wandb` en local et vous connecter : ## Accédez à vos données par programmation
-Vous pouvez accéder aux informations que nous avons collectées de trois façons : dans le processus Python d’origine en cours d’enregistrement à l’aide de la [bibliothèque cliente `wandb`](/fr/models/ref/python/), via l’[interface de l’application web](/fr/models/track/workspaces/), ou par programmation à l’aide de [notre API publique](/fr/models/ref/python/public-api/). Les `Parameter`s sont enregistrés dans le [`config`](/fr/models/) de W&B et sont disponibles dans l’[onglet Vue d’ensemble](/fr/models/runs/#overview-tab). Les `datasets`, `models` et `others` sont enregistrés dans [W&B Artifacts](/fr/models/artifacts/) et sont disponibles dans l’[onglet Artifacts](/fr/models/runs/#artifacts-tab). Les types Python de base sont enregistrés dans le dict [`summary`](/fr/models/) de W&B et sont disponibles dans l’onglet Vue d’ensemble. Voir notre [guide de l’API publique](/fr/models/track/public-api-guide/) pour en savoir plus sur l’utilisation de l’API afin d’obtenir ces informations par programmation depuis l’extérieur. +Une fois vos flows et vos étapes décorés, les exécutions envoient des paramètres et des artefacts à W&B chaque fois que le flow s’exécute. Vous pouvez accéder aux informations capturées de trois façons : dans le processus Python d’origine en cours d’enregistrement à l’aide de la [bibliothèque cliente `wandb`](/fr/models/ref/python/), via l’[interface de l’application web](/fr/models/track/workspaces/), ou par programmation à l’aide de l’[API publique](/fr/models/ref/python/public-api/). Les `Parameter`s sont enregistrés dans le [`config`](/fr/models/) de W&B et sont disponibles dans l’[onglet Vue d’ensemble](/fr/models/runs/#overview-tab). Les `datasets`, `models` et `others` sont enregistrés dans [W&B Artefacts](/fr/models/artifacts/) et sont disponibles dans l’[onglet Artefacts](/fr/models/runs/#artifacts-tab). Les types Python de base sont enregistrés dans le dict [`summary`](/fr/models/) de W&B et sont disponibles dans l’onglet Vue d’ensemble. Voir le [guide de l’API publique](/fr/models/track/public-api-guide/) pour en savoir plus sur l’utilisation de l’API afin d’obtenir ces informations par programmation depuis l’extérieur.
### Référence rapide @@ -177,41 +181,43 @@ Vous pouvez accéder aux informations que nous avons collectées de trois façon ### Arguments de `wandb_log`
-| kwarg | Options | -| ---------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | -| `datasets` |
  • True: Journaliser les variables d’instance correspondant à un jeu de données
  • False
| -| `models` |
  • True: Journaliser les variables d’instance correspondant à un modèle
  • False
| -| `others` |
  • True: Journaliser tout autre élément sérialisable avec pickle
  • False
| -| `settings` |
  • wandb.Settings(...): Spécifiez vos propres paramètres wandb pour cette étape ou ce flow
  • None: Équivaut à passer wandb.Settings()

Par défaut, si :

  • settings.run_group vaut None, il sera défini sur {flow_name}/{run_id}
  • settings.run_job_type vaut None, il sera défini sur {run_job_type}/{step_name}
| +| kwarg | Options | +| ---------- | ----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | +| `datasets` |
  • True: Journaliser les variables d’instance correspondant à un jeu de données
  • False
| +| `models` |
  • True: Journaliser les variables d’instance correspondant à un modèle
  • False
| +| `others` |
  • True: Journaliser tout autre élément sérialisable avec pickle
  • False
| +| `settings` |
  • wandb.Settings(...): Spécifiez vos propres paramètres wandb pour cette étape ou ce flow
  • None: Équivaut à passer wandb.Settings()

Par défaut, si :

  • settings.run_group vaut None, il est défini sur {flow_name}/{run_id}
  • settings.run_job_type vaut None, il est défini sur {run_job_type}/{step_name}
|
## Questions fréquentes
-
- ### Qu’enregistrez-vous exactement ? Enregistrez-vous toutes les variables d’instance et les variables locales ? +Les sections suivantes répondent aux questions courantes sur la journalisation, les types de données pris en charge et la traçabilité des artefacts. + +
+ ### Qu’enregistrez-vous exactement
-`wandb_log` enregistre uniquement les variables d’instance. Les variables locales ne sont JAMAIS enregistrées. Cela permet d’éviter d’enregistrer des données inutiles. +`wandb_log` enregistre uniquement les variables d’instance. Les variables locales ne sont jamais enregistrées. Cela permet d’éviter d’enregistrer des données inutiles.
- ### Quels types de données sont enregistrés ? + ### Quels types de données sont enregistrés
-Nous prenons actuellement en charge les types suivants : +W&B prend en charge les types suivants : -| Paramètre de journalisation | Type | -| ---------------------------- | ---------------------------------------------------------------------------------------------------------------------------- | -| par défaut (toujours activé) |
  • dict, list, set, str, int, float, bool
| -| `datasets` |
  • pd.DataFrame
  • pathlib.Path
| -| `models` |
  • nn.Module
  • sklearn.base.BaseEstimator
| -| `others` |
| +| Paramètre de journalisation | Type | +| ---------------------------- | ----------------------------------------------------------------------------------------------------------------------------------------- | +| par défaut (toujours activé) |
  • dict, list, set, str, int, float, bool
| +| `datasets` |
  • pd.DataFrame
  • pathlib.Path
| +| `models` |
  • nn.Module
  • sklearn.base.BaseEstimator
| +| `others` | | -
- ### Comment puis-je configurer le comportement de journalisation ? +
+ ### Configurer le comportement de journalisation
-| Type de variable | comportement | Exemple | Type de données | +| Type de variable | Comportement | Exemple | Type de données | | ---------------- | ---------------------------------- | --------------- | --------------- | | Instance | Enregistré automatiquement | `self.accuracy` | `float` | | Instance | Enregistré si `datasets=True` | `self.df` | `pd.DataFrame` | @@ -219,10 +225,10 @@ Nous prenons actuellement en charge les types suivants : | Locale | Jamais enregistré | `accuracy` | `float` | | Locale | Jamais enregistré | `df` | `pd.DataFrame` | -
- ### La traçabilité des artifacts est-elle prise en charge ? +
+ ### Suivi de la traçabilité des artefacts
-Oui. Si vous avez un artifact qui est la sortie de l’étape A et l’entrée de l’étape B, nous construisons automatiquement le DAG de traçabilité pour vous. +Si vous avez un artefact qui est la sortie de l’étape A et l’entrée de l’étape B, W&B construit automatiquement le DAG de traçabilité pour vous. -Pour voir un exemple de ce comportement, consultez ce [notebook](https://colab.research.google.com/drive/1wZG-jYzPelk8Rs2gIM3a71uEoG46u_nG#scrollTo=DQQVaKS0TmDU) et la [page W&B Artifacts correspondante](https://wandb.ai/megatruong/metaflow_integration/artifacts/dataset/raw_df/7d14e6578d3f1cfc72fe/graph) \ No newline at end of file +Pour voir un exemple de ce comportement, consultez ce [notebook d’exemple d’intégration Metaflow](https://colab.research.google.com/drive/1wZG-jYzPelk8Rs2gIM3a71uEoG46u_nG#scrollTo=DQQVaKS0TmDU) et la [page Artifacts correspondante](https://wandb.ai/megatruong/metaflow_integration/artifacts/dataset/raw_df/7d14e6578d3f1cfc72fe/graph). \ No newline at end of file diff --git a/fr/models/integrations/mmengine.mdx b/fr/models/integrations/mmengine.mdx index 9f273aec34..3e53f8e3ec 100644 --- a/fr/models/integrations/mmengine.mdx +++ b/fr/models/integrations/mmengine.mdx @@ -3,13 +3,15 @@ title: MMEngine description: "Utilisez W&B avec MMEngine d'OpenMMLab via WandbVisBackend pour journaliser les métriques d'entraînement, les configurations et les enregistrements visuels." --- -MMEngine d'[OpenMMLab](https://github.com/open-mmlab) est une bibliothèque de base pour entraîner des modèles de deep learning basés sur PyTorch. MMEngine met en œuvre une architecture d'entraînement de nouvelle génération pour la bibliothèque d'algorithmes d'OpenMMLab, en fournissant une base d'exécution unifiée pour plus de 30 bibliothèques d'algorithmes au sein d'OpenMMLab. Ses composants principaux incluent le moteur d'entraînement, le moteur d'évaluation et la gestion des modules. +Cette page vous montre comment utiliser W&B avec MMEngine d'OpenMMLab pour suivre et visualiser les exécutions d'entraînement. Utilisez-la si vous entraînez des modèles de deep learning avec MMEngine ou les bibliothèques de vision par ordinateur d'OpenMMLab et que vous souhaitez journaliser des métriques, des configurations et des visualisations dans W&B. -[W&B](https://wandb.ai/site) est directement intégré à MMEngine via un [`WandbVisBackend`](https://mmengine.readthedocs.io/en/latest/api/generated/mmengine.visualization.WandbVisBackend.html#mmengine.visualization.WandbVisBackend) dédié, qui peut être utilisé pour +MMEngine d'[OpenMMLab](https://github.com/open-mmlab) est une bibliothèque de base pour entraîner des modèles de deep learning basés sur PyTorch. MMEngine met en œuvre une architecture d'entraînement pour la bibliothèque d'algorithmes d'OpenMMLab, en fournissant une base d'exécution unifiée pour plus de 30 bibliothèques d'algorithmes au sein d'OpenMMLab. Ses composants principaux incluent le moteur d'entraînement, le moteur d'évaluation et la gestion des modules. + +MMEngine s'intègre directement à [W&B](https://wandb.ai/site) via un [`WandbVisBackend`](https://mmengine.readthedocs.io/en/latest/api/generated/mmengine.visualization.WandbVisBackend.html#mmengine.visualization.WandbVisBackend) dédié que vous pouvez utiliser pour : * journaliser les métriques d'entraînement et d'évaluation. * journaliser et gérer les configurations d'expérience. -* journaliser des enregistrements supplémentaires, tels que des graphes, des images, des scalaires, etc. +* journaliser des enregistrements supplémentaires, tels que des graphes, des images et des scalaires.
## Prise en main @@ -48,17 +50,17 @@ Installez ensuite `mmengine` et `mmcv` avec `mim`.
- ## Utiliser `WandbVisBackend` avec le Runner MMEngine + ## Utiliser `WandbVisBackend` avec le runner MMEngine
-Cette section montre un flux de travail type avec `WandbVisBackend` en utilisant [`mmengine.runner.Runner`](https://mmengine.readthedocs.io/en/latest/api/generated/mmengine.runner.Runner.html#mmengine.runner.Runner). +Cette section présente un flux de travail typique avec `WandbVisBackend` et [`mmengine.runner.Runner`](https://mmengine.readthedocs.io/en/latest/api/generated/mmengine.runner.Runner.html#mmengine.runner.Runner). Le visualiseur encapsule le backend W&B afin que le runner MMEngine puisse acheminer les logs vers W&B pendant l’entraînement. -1. Définissez un `visualizer` à partir d'une configuration de visualisation. +1. Définissez un `visualizer` à partir d’une configuration de visualisation. Le visualiseur est l’élément que le runner utilise pour transmettre les logs au backend configuré. ```python from mmengine.visualization import Visualizer - # définir la configuration de visualisation + # définir les configurations de visualisation visualization_cfg = dict( name="wandb_visualizer", vis_backends=[ @@ -70,27 +72,25 @@ Cette section montre un flux de travail type avec `WandbVisBackend` en utilisant save_dir="runs/wandb" ) - # obtenir le visualizer à partir de la configuration de visualisation + # obtenir le visualiseur à partir des configurations de visualisation visualizer = Visualizer.get_instance(**visualization_cfg) ``` - - Passez à `init_kwargs` un dictionnaire d'arguments correspondant aux paramètres d'entrée de [l'initialisation d'un run W&B](/fr/models/ref/python/functions/init). - + Vous passez à `init_kwargs` un dictionnaire d’arguments correspondant aux paramètres d’entrée de [l’initialisation d’un W&B Run](/fr/models/ref/python/functions/init). -2. Initialisez un `runner` avec le `visualizer`, puis appelez `runner.train()`. +2. Initialisez un `runner` avec le `visualizer`, puis appelez `runner.train()` pour démarrer l’entraînement. Le runner utilise le visualiseur pour transmettre les métriques et les configurations à W&B. ```python from mmengine.runner import Runner - # construire le Runner mmengine, un utilitaire d'entraînement pour PyTorch + # construire le Runner mmengine, qui est un assistant d'entraînement pour PyTorch runner = Runner( model, work_dir='runs/gan/', train_dataloader=train_dataloader, train_cfg=train_cfg, optim_wrapper=opt_wrapper_dict, - visualizer=visualizer, # passer le visualizer + visualizer=visualizer, # transmettre le visualiseur ) # démarrer l'entraînement @@ -98,16 +98,16 @@ Cette section montre un flux de travail type avec `WandbVisBackend` en utilisant ```
- ## Utilisez `WandbVisBackend` avec les bibliothèques OpenMMLab de vision par ordinateur + ## Utiliser le `WandbVisBackend` avec les bibliothèques de vision par ordinateur d’OpenMMLab
-`WandbVisBackend` s’utilise aussi facilement pour suivre les expériences avec des bibliothèques OpenMMLab de vision par ordinateur, comme [MMDetection](https://mmdetection.readthedocs.io/). +Vous pouvez également utiliser le `WandbVisBackend` pour suivre les expériences avec des bibliothèques de vision par ordinateur d’OpenMMLab telles que [MMDetection](https://mmdetection.readthedocs.io/). L’exemple suivant redéfinit l’entrée `vis_backends` d’une configuration de base afin que le visualiseur existant journalise sur W&B. ```python # hériter des configurations de base des configurations d'exécution par défaut _base_ = ["../_base_/default_runtime.py"] -# Assigner le dict de configuration `WandbVisBackend` aux +# Attribuer le dictionnaire de configuration `WandbVisBackend` à # `vis_backends` du `visualizer` depuis les configurations de base _base_.visualizer.vis_backends = [ dict( @@ -118,4 +118,4 @@ _base_.visualizer.vis_backends = [ }, ), ] -``` +``` \ No newline at end of file diff --git a/fr/models/integrations/mmf.mdx b/fr/models/integrations/mmf.mdx index 756d0c4d78..e84692268d 100644 --- a/fr/models/integrations/mmf.mdx +++ b/fr/models/integrations/mmf.mdx @@ -3,13 +3,13 @@ description: "Intégrez W&B au framework MMF de Meta AI pour suivre les expérie title: MMF --- -La classe `WandbLogger` de la bibliothèque [MMF de Meta AI](https://github.com/facebookresearch/mmf) permet à W&B de consigner les métriques d'entraînement et de validation, les métriques système (GPU et CPU), les points de contrôle du modèle et les paramètres de configuration. +Cette page décrit comment utiliser la classe `WandbLogger` de la bibliothèque [MMF de Meta AI](https://github.com/facebookresearch/mmf) pour suivre l'entraînement de votre modèle multimodal avec W&B. L'activation de `WandbLogger` permet à W&B de consigner les métriques d'entraînement et de validation, les métriques système (GPU et CPU), les points de contrôle du modèle et les paramètres de configuration, afin de surveiller les expériences et de comparer les runs sans ajouter de code de journalisation personnalisé. -
- ## Fonctionnalités actuelles +
+ ## Fonctionnalités
-Les fonctionnalités suivantes sont prises en charge par le `WandbLogger` dans MMF : +Le `WandbLogger` dans MMF prend en charge les fonctionnalités suivantes : * Métriques d'entraînement et de validation * Évolution du taux d'apprentissage @@ -17,30 +17,30 @@ Les fonctionnalités suivantes sont prises en charge par le `WandbLogger` dans M * Métriques système GPU et CPU * Paramètres de configuration de l'entraînement -
+
## Paramètres de configuration
-Les options suivantes sont disponibles dans la configuration MMF pour activer et personnaliser la journalisation de wandb : +Pour activer la journalisation W&B et personnaliser le suivi des exécutions, définissez les options suivantes dans votre configuration MMF : -``` +```yaml training: wandb: enabled: true - # Une entité est un nom d'utilisateur ou un nom d'équipe vers lequel vous envoyez des runs. - # Par défaut, le run sera enregistré dans votre compte utilisateur. + # Une entité est un nom d'utilisateur ou un nom d'équipe vers lequel vous envoyez des run. + # Par défaut, le run est journalisé dans votre compte utilisateur. entity: null - # Nom du projet à utiliser lors de l'enregistrement de l'expérience avec wandb + # Nom du projet à utiliser lors de la journalisation de l'expérience avec wandb project: mmf - # Nom de l'expérience/run à utiliser lors de l'enregistrement de l'expérience + # Nom de l'expérience/run à utiliser lors de la journalisation de l'expérience # dans le projet avec wandb. Le nom d'expérience par défaut # est : ${training.experiment_name} name: ${training.experiment_name} - # Activer le point de contrôle du modèle, en sauvegardant les points de contrôle du modèle dans W&B Artifacts + # Activer les points de contrôle du modèle, en sauvegardant les points de contrôle dans W&B Artifacts log_model_checkpoint: true # Valeurs d'arguments supplémentaires à transmettre à wandb.init(), par exemple : @@ -48,7 +48,7 @@ training: # tags: ['tag1', 'tag2'] env: - # Pour modifier le chemin vers le répertoire où les métadonnées wandb seront - # stockées (par défaut : env.log_dir) : + # Pour modifier le chemin vers le répertoire où les métadonnées wandb sont + # stockées (Par défaut : env.log_dir) : wandb_logdir: ${env:MMF_WANDB_LOGDIR,} ``` \ No newline at end of file diff --git a/fr/models/integrations/nim.mdx b/fr/models/integrations/nim.mdx index 2d1b509f6b..45496dfe5d 100644 --- a/fr/models/integrations/nim.mdx +++ b/fr/models/integrations/nim.mdx @@ -3,37 +3,38 @@ title: Job de déploiement vers NVIDIA NeMo Inference Microservice description: "Déployez un artifact de modèle W&B vers NVIDIA NeMo Inference Microservice à l’aide de W&B Launch pour servir des modèles à grande échelle." --- -Déployez un artifact de modèle depuis W&B vers NVIDIA NeMo Inference Microservice. Pour ce faire, utilisez W&B Launch. W&B Launch convertit les artifacts de modèle au format NVIDIA NeMo Model, puis les déploie sur un serveur NIM/Triton en cours d’exécution. +Ce guide vous montre comment déployer un artifact de modèle depuis W&B vers NVIDIA NeMo Inference Microservice (NIM) afin de servir le modèle pour l’inférence à grande échelle. Pour ce faire, utilisez W&B Launch. W&B Launch convertit les artifacts de modèle au format NVIDIA NeMo Model, puis les déploie sur un serveur NIM/Triton en cours d’exécution. Cela vous permet de déployer directement un modèle W&B suivi vers un point de terminaison prêt pour la production, sans conversion manuelle. -W&B Launch prend actuellement en charge les types de modèles compatibles suivants : +W&B Launch accepte les types de modèles compatibles suivants : -1. [Llama2](https://llama.meta.com/llama2/) -2. [StarCoder](https://github.com/bigcode-project/starcoder) -3. NV-GPT (bientôt disponible) +* [Llama2](https://llama.meta.com/llama2/) +* [StarCoder](https://github.com/bigcode-project/starcoder) - Le temps de déploiement varie selon le modèle et le type de machine. La configuration de base de Llama2-7b prend environ 1 minute sur l’instance Google Cloud `a2-ultragpu-1g`. + Le temps de déploiement varie selon le modèle et le type de machine. La configuration de base `Llama2-7b` prend environ 1 minute sur Google Cloud's `a2-ultragpu-1g`.
## Démarrage rapide
-1. [Créez une Launch queue](/fr/platform/launch/add-job-to-queue/) si vous n'en avez pas déjà une. Voir un exemple de configuration de file d'attente ci-dessous. +Suivez ces étapes pour créer une file d’attente Launch, enregistrer le job de déploiement, lancer un agent et soumettre le déploiement. + +1. [Créez une file d’attente Launch](/fr/platform/launch/add-job-to-queue/) si vous n’en avez pas encore. La file d’attente définit la manière dont le job s’exécute sur votre machine équipée d’un GPU. Voir l’exemple suivant de configuration de la file d’attente. ```yaml net: host gpus: all # peut être un ensemble spécifique de GPU ou `all` pour tout utiliser - runtime: nvidia # nécessite également le runtime de conteneur nvidia + runtime: nvidia # nécessite également le runtime de conteneur NVIDIA volume: - model-store:/model-store/ ``` - image + Configuration de la file d’attente Launch dans l’interface W&B -2. Créez ce job dans votre projet : +2. Créez ce job dans votre projet. Cela enregistre le code du job de déploiement dans votre projet W&B afin que Launch puisse l’exécuter. ```bash wandb job create -n "deploy-to-nvidia-nemo-inference-microservice" \ @@ -44,30 +45,31 @@ W&B Launch prend actuellement en charge les types de modèles compatibles su git https://github.com/wandb/launch-jobs ``` -3. Lancez un agent sur votre machine équipée d'un GPU : +3. Lancez un agent sur votre machine équipée d’un GPU. L’agent interroge la file d’attente et exécute le job de déploiement lorsque vous le soumettez. ```bash wandb launch-agent -e $ENTITY -p $PROJECT -q $QUEUE ``` -4. Soumettez le launch job de déploiement avec les configurations souhaitées depuis la [Launch UI](https://wandb.ai/launch) - 1. Vous pouvez aussi le soumettre via la CLI : - ```bash - wandb launch -d gcr.io/playground-111/deploy-to-nemo:latest \ - -e $ENTITY \ - -p $PROJECT \ - -q $QUEUE \ - -c $CONFIG_JSON_FNAME - ``` - - image - - -5. Vous pouvez suivre le processus de déploiement dans la Launch UI. +4. Soumettez le job Launch de déploiement avec les configurations souhaitées depuis l’[interface W&B Launch](https://wandb.ai/launch). Vous pouvez également le soumettre via la CLI. + + ```bash + wandb launch -d gcr.io/playground-111/deploy-to-nemo:latest \ + -e $ENTITY \ + -p $PROJECT \ + -q $QUEUE \ + -c $CONFIG_JSON_FNAME + ``` + + + Soumission d’un job Launch depuis l’interface W&B Launch + + +5. Vous pouvez suivre le processus de déploiement dans l’interface W&B Launch. - image + Suivi de la progression du déploiement dans l’interface W&B Launch -6. Une fois l'opération terminée, vous pouvez immédiatement appeler l'endpoint avec `curl` pour tester le modèle. Le nom du modèle est toujours `ensemble`. +6. Une fois le déploiement terminé, le point de terminaison NIM/Triton sert le modèle et est prêt à recevoir des requêtes d’inférence. Pour tester le modèle, utilisez `curl` sur le point de terminaison. Le nom du modèle est toujours `ensemble`. ```bash #!/bin/bash curl -X POST "http://0.0.0.0:9999/v1/completions" \ diff --git a/fr/models/integrations/openai-api.mdx b/fr/models/integrations/openai-api.mdx index 60ecce942e..02df8f1f5e 100644 --- a/fr/models/integrations/openai-api.mdx +++ b/fr/models/integrations/openai-api.mdx @@ -7,27 +7,27 @@ import { ColabLink } from '/snippets/fr/_includes/colab-link.mdx'; -Utilisez l'intégration de l'API OpenAI de W&B pour journaliser les requêtes, les réponses, le nombre de tokens et les métadonnées des modèles pour tous les modèles OpenAI, y compris les modèles affinés. +Utilisez l'intégration de l'API OpenAI de W&B pour journaliser les requêtes, les réponses, le nombre de tokens et les métadonnées des modèles pour tous les modèles OpenAI, y compris les modèles affinés. Utilisez cette intégration si vous appelez l'API OpenAI et souhaitez avoir de la visibilité sur vos prompts, vos complétions et votre utilisation sans ajouter de code de journalisation manuelle. + +En journalisant les inputs et sorties de votre API, vous pouvez rapidement évaluer les performances de différents prompts, comparer différents paramètres de modèle (comme la température) et suivre d'autres métriques d'utilisation, comme l'utilisation des tokens. Voir l'[intégration OpenAI pour le Fine-tuning](./openai-fine-tuning) pour savoir comment utiliser W&B afin de suivre vos expériences de Fine-tuning, vos modèles et vos jeux de données, et partager vos résultats avec vos collègues. -En journalisant les inputs et sorties de votre API, vous pouvez rapidement évaluer les performances de différents prompts, comparer différents paramètres de modèle (comme la température) et suivre d'autres métriques d'utilisation, comme l'utilisation des tokens. - - Journalisation automatique de l'API OpenAI + Vue de trace W&B affichant les requêtes API OpenAI, les réponses et l'utilisation des tokens journalisées automatiquement
## Installez la bibliothèque API Python d’OpenAI
-L’intégration autolog de W&B fonctionne avec la version 0.28.1 d’OpenAI et les versions antérieures. +L’intégration autolog de W&B fonctionne avec la version 0.28.1 d’OpenAI et les versions antérieures, vous devez donc installer une version compatible avant d’activer la journalisation automatique. -Pour installer API Python d’OpenAI version 0.28.1, exécutez : +Pour installer API Python d’OpenAI version 0.28.1 : -```python +```bash pip install openai==0.28.1 ``` @@ -35,11 +35,13 @@ pip install openai==0.28.1 ## Utiliser l’API Python d’OpenAI
-
- ### 1. Importez autolog et initialisez-le +Les étapes suivantes expliquent comment activer la journalisation automatique, appeler l’API OpenAI et consulter les traces obtenues dans W&B. + +
+ ### Importez et initialisez autolog
-Tout d’abord, importez `autolog` à partir de `wandb.integration.openai`, puis initialisez-le. +Tout d’abord, importez `autolog` à partir de `wandb.integration.openai`, puis initialisez-le. Cela configure le run W&B qui capture chaque appel à l’API OpenAI effectué par la suite. ```python import os @@ -49,13 +51,13 @@ from wandb.integration.openai import autolog autolog({"project": "gpt5"}) ``` -Vous pouvez aussi passer à `autolog` un dictionnaire contenant les arguments acceptés par `wandb.init()`. Cela inclut un nom de projet, un nom d’équipe, une entité, et plus encore. Pour plus d’informations sur [`wandb.init()`](/fr/models/ref/python/functions/init), consultez le guide de référence de l’API. +Vous pouvez aussi passer à `autolog` un dictionnaire contenant les arguments acceptés par `wandb.init()`. Cela inclut un nom de projet, un nom d’équipe, une entité, et plus encore. Pour plus d’informations, voir la [référence de l’API `wandb.init()`](/fr/models/ref/python/functions/init). -
- ### 2. Appelez l’API OpenAI +
+ ### Appelez l’API OpenAI
-Chaque appel à l’API OpenAI est désormais automatiquement enregistré dans W&B. +Lorsque l’autolog est activé, W&B journalise automatiquement chaque appel que vous effectuez à l’API OpenAI. Vous n’avez pas besoin d’ajouter de code de journalisation à votre code d’appel d’API existant. ```python os.environ["OPENAI_API_KEY"] = "XXX" @@ -72,22 +74,22 @@ chat_request_kwargs = dict( response = openai.ChatCompletion.create(**chat_request_kwargs) ``` -
- ### 3. Consultez les inputs et les réponses de votre API OpenAI +
+ ### Consultez les entrées et les réponses de votre API OpenAI
-Cliquez sur le lien W&B [run](/fr/models/runs/) généré par `autolog` à l'**étape 1**. Vous êtes alors redirigé vers l'espace de travail du projet dans W&B App. +Après avoir effectué un ou plusieurs appels d’API, vous pouvez examiner les données capturées dans W&B. + +Cliquez sur le lien W&B [run](/fr/models/runs/) généré par `autolog`. Vous êtes alors redirigé vers l’espace de travail de votre projet dans W&B. -Sélectionnez un run que vous avez créé pour afficher le tableau des traces, la chronologie de la trace et l'architecture du modèle du LLM OpenAI utilisé. +Sélectionnez un run que vous avez créé pour afficher le tableau de traces, la chronologie des traces et l’architecture du modèle du LLM OpenAI utilisé.
## Désactiver l’autolog
-W&B recommande d’appeler `disable()` pour fermer tous les processus W&B lorsque vous avez fini d’utiliser l’API OpenAI. +Appelez `disable()` pour fermer tous les processus W&B lorsque vous avez fini d’utiliser l’API OpenAI. Cela garantit que W&B vide toutes les données en attente et ne capture pas d’autres appels d’API par inadvertance. ```python autolog.disable() -``` - -Désormais, vos inputs et completions seront enregistrés dans W&B, prêts à être analysés ou partagés avec vos collègues. +``` \ No newline at end of file diff --git a/fr/models/integrations/openai-fine-tuning.mdx b/fr/models/integrations/openai-fine-tuning.mdx index cca5620657..62f95f58ae 100644 --- a/fr/models/integrations/openai-fine-tuning.mdx +++ b/fr/models/integrations/openai-fine-tuning.mdx @@ -7,37 +7,37 @@ import { ColabLink } from '/snippets/fr/_includes/colab-link.mdx'; -Enregistrez dans W&B les métriques et la configuration de fine-tuning de votre modèle OpenAI GPT-3.5 ou GPT-4. Exploitez l'écosystème W&B pour suivre vos expériences, modèles et jeux de données de fine-tuning, et partager vos résultats avec vos collègues. +Cette page explique comment enregistrer dans W&B les métriques et la configuration de fine-tuning de votre modèle OpenAI GPT-3.5 ou GPT-4. En intégrant W&B à l'API de fine-tuning d'OpenAI, vous pouvez suivre vos expériences, modèles et jeux de données de fine-tuning au même endroit et partager les résultats avec vos collègues. Utilisez cette intégration lorsque vous effectuez le fine-tuning de modèles OpenAI et souhaitez un suivi centralisé des expériences ainsi qu'un contrôle de version sur les données d'entraînement et les modèles obtenus. - Voir la [documentation OpenAI](https://platform.openai.com/docs/guides/fine-tuning/which-models-can-be-fine-tuned) pour obtenir la liste des modèles que vous pouvez soumettre à un fine-tuning. + Voir la [documentation OpenAI](https://platform.openai.com/docs/guides/fine-tuning/which-models-can-be-fine-tuned) pour obtenir la liste des modèles pour lesquels vous pouvez effectuer le fine-tuning. Voir la section [Intégration W&B](https://developers.openai.com/cookbook/examples/third_party/gpt_finetuning_with_wandb) dans la documentation OpenAI pour plus d'informations sur l'intégration de W&B avec OpenAI pour le fine-tuning.
- ## Installer ou mettre à jour OpenAI Python API + ## Installer ou mettre à jour API Python OpenAI
-L’intégration W&B OpenAI Fine-tuning fonctionne avec OpenAI à partir de la version 1.0. Voir la documentation PyPI pour accéder à la dernière version de la bibliothèque [OpenAI Python API](https://pypi.org/project/openai/). +Avant de synchroniser les résultats de fine-tuning, assurez-vous qu’une version compatible du client Python OpenAI est installée. L’intégration W&B OpenAI Fine-tuning fonctionne avec OpenAI à partir de la version 1.0. Voir la documentation PyPI pour accéder à la dernière version de la bibliothèque [API Python OpenAI](https://pypi.org/project/openai/). -Pour installer OpenAI Python API, exécutez : +Pour installer API Python OpenAI, exécutez : -```python +```bash pip install openai ``` -Si l’API Python d’OpenAI est déjà installée, vous pouvez la mettre à jour avec : +Si l’API Python d’OpenAI est déjà installée, mettez-la à jour avec : -```python +```bash pip install -U openai ```
- ## Synchronisez les résultats de votre fine-tuning OpenAI + ## Synchronisez vos résultats de fine-tuning OpenAI
-Intégrez W&B à l'API de fine-tuning d'OpenAI pour enregistrer dans W&B les métriques et la configuration de votre fine-tuning. Pour ce faire, utilisez la classe `WandbLogger` du module `wandb.integration.openai.fine_tuning`. +Cette section explique comment envoyer les métriques et la configuration d’un job de fine-tuning OpenAI vers W&B afin de pouvoir les consulter aux côtés de vos autres Experiments. Pour ce faire, utilisez la classe `WandbLogger` du module `wandb.integration.openai.fine_tuning`. ```python from wandb.integration.openai.fine_tuning import WandbLogger @@ -55,7 +55,7 @@ WandbLogger.sync(fine_tune_job_id=FINETUNE_JOB_ID) ### Synchronisez vos fine-tunings
-Synchronisez vos résultats depuis votre script +Synchronisez vos résultats depuis votre script. L'exemple suivant montre à la fois l'appel minimal en une seule ligne et l'ensemble complet des paramètres facultatifs que vous pouvez transmettre pour définir le comportement de la synchronisation. ```python from wandb.integration.openai.fine_tuning import WandbLogger @@ -80,28 +80,32 @@ WandbLogger.sync( ### Référence
-| Argument | Description | -| -------------------------------- | --------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | -| fine_tune_job_id | Il s’agit de l’ID OpenAI Fine-Tune que vous obtenez lorsque vous créez votre job de fine-tuning avec `client.fine_tuning.jobs.create`. Si cet argument vaut None (valeur par défaut), tous les jobs OpenAI de fine-tuning qui n’ont pas encore été synchronisés le seront avec W&B. | -| openai_client | Passez un client OpenAI initialisé à `sync`. Si aucun client n’est fourni, il est initialisé par le logger lui-même. Par défaut, sa valeur est None. | -| num_fine_tunes | Si aucun ID n’est fourni, tous les fine-tunings non synchronisés seront enregistrés dans W&B. Cet argument vous permet de sélectionner le nombre de fine-tunings récents à synchroniser. Si num_fine_tunes vaut 5, les 5 fine-tunings les plus récents sont sélectionnés. | -| project | nom du projet W&B dans lequel seront enregistrés vos métriques, modèles, données, etc. de fine-tuning. Par défaut, le nom du projet est "OpenAI-Fine-Tune." | -| entity | Nom d’utilisateur W&B ou nom d’équipe vers lequel vous envoyez les runs. Par défaut, votre entité par défaut est utilisée, généralement votre nom d’utilisateur. | -| overwrite | Force la journalisation et écrase le run wandb existant du même job de fine-tuning. Par défaut, cette valeur est False. | -| wait_for_job_success | Une fois qu’un job OpenAI de fine-tuning est lancé, il prend généralement un certain temps. Pour garantir que vos métriques soient enregistrées dans W&B dès que le job de fine-tuning est terminé, ce paramètre vérifie toutes les 60 secondes si le statut du job de fine-tuning passe à `succeeded`. Dès que le job de fine-tuning est détecté comme réussi, les métriques sont automatiquement synchronisées avec W&B. La valeur par défaut est True. | -| model_artifact_name | Le nom de l'artifact de modèle enregistré. La valeur par défaut est `"model-metadata"`. | -| model_artifact_type | Le type de l'artifact de modèle enregistré. La valeur par défaut est `"model"`. | -| **kwargs_wandb_init | Tout argument supplémentaire transmis directement à [`wandb.init()`](/fr/models/ref/python/functions/init) | +Le tableau suivant décrit chaque argument accepté par `WandbLogger.sync`. + +| Argument | Description | +| ---------------------- | ----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | +| `fine_tune_job_id` | L’ID de fine-tuning OpenAI que vous obtenez lorsque vous créez votre job de fine-tuning avec `client.fine_tuning.jobs.create`. Si cet argument vaut `None` (par défaut), W&B synchronise tous les jobs de fine-tuning OpenAI qui n’ont pas encore été synchronisés. | +| `openai_client` | Transmettez un client OpenAI initialisé à `sync`. Si vous ne fournissez pas de client, le logger en initialise un. La valeur par défaut est `None`. | +| `num_fine_tunes` | Si vous ne fournissez pas d’ID, W&B journalise tous les fine-tunings non synchronisés. Cet argument vous permet de sélectionner le nombre de fine-tunings les plus récents à synchroniser. Si `num_fine_tunes` vaut 5, W&B sélectionne les 5 fine-tunings les plus récents. | +| `project` | Nom du projet W&B dans lequel W&B journalise les métriques, modèles, données, etc. de votre fine-tuning. Par défaut, le nom du projet est `"OpenAI-Fine-Tune"`. | +| `entity` | Nom d’utilisateur W&B ou nom d’équipe où vous envoyez les runs. Par défaut, W&B utilise votre entité par défaut, qui correspond généralement à votre nom d’utilisateur. | +| `overwrite` | Force la journalisation et remplace le run `wandb` existant pour le même job de fine-tuning. La valeur par défaut est `False`. | +| `wait_for_job_success` | Un job de fine-tuning OpenAI prend un certain temps après son démarrage. Pour garantir que W&B journalise vos métriques dès que le job de fine-tuning se termine, ce paramètre vérifie toutes les 60 secondes si le statut du job de fine-tuning passe à `succeeded`. Une fois le job de fine-tuning terminé avec succès, W&B synchronise automatiquement les métriques. La valeur par défaut est `True`. | +| `model_artifact_name` | Le nom de l’artifact de modèle enregistré. La valeur par défaut est `"model-metadata"`. | +| `model_artifact_type` | Le type de l’artifact de modèle enregistré. La valeur par défaut est `"model"`. | +| `**kwargs_wandb_init` | Tout argument supplémentaire transmis directement à [`wandb.init()`](/fr/models/ref/python/functions/init). |
## Gestion des versions et visualisation des jeux de données
+Lorsque vous synchronisez un job de fine-tuning, W&B capture également les données d'entraînement et de validation afin que vous puissiez en gérer les versions et les explorer de manière interactive. Les sous-sections suivantes décrivent les éléments suivis par W&B et comment les consulter. +
### Gestion des versions
-Les données d'entraînement et de validation que vous téléversez dans OpenAI pour le Fine-tuning sont automatiquement enregistrées dans W&B Artifacts afin de faciliter la gestion des versions. Ci-dessous, vous voyez une vue du fichier d'entraînement dans Artifacts. Vous pouvez y voir le run W&B qui a enregistré ce fichier, la date à laquelle il a été enregistré, la version du jeu de données correspondante, les métadonnées et la traçabilité du DAG, des données d'entraînement jusqu'au modèle entraîné. +Les données d'entraînement et de validation que vous téléversez dans OpenAI pour le Fine-tuning sont automatiquement enregistrées dans W&B Artifacts afin de faciliter la gestion des versions. L'image suivante montre une vue du fichier d'entraînement dans Artifacts. Vous pouvez y voir le run W&B qui a enregistré ce fichier, la date à laquelle il a été enregistré, la version du jeu de données correspondante, les métadonnées et la traçabilité du DAG, des données d'entraînement jusqu'au modèle entraîné. W&B Artifacts avec des jeux de données d'entraînement @@ -111,7 +115,7 @@ Les données d'entraînement et de validation que vous téléversez dans Ope ### Visualisation
-Les jeux de données s’affichent dans W&B Tables, ce qui vous permet de les explorer, d’y effectuer des recherches et d’interagir avec eux. Consultez ci-dessous les exemples d’entraînement visualisés avec W&B Tables. +W&B affiche les jeux de données dans W&B Tables, ce qui vous permet de les explorer, d’y effectuer des recherches et d’interagir avec eux. L’image suivante montre les exemples d’entraînement visualisés avec W&B Tables. Données OpenAI @@ -121,7 +125,7 @@ Les jeux de données s’affichent dans W&B Tables, ce qui vous permet de le ## Le modèle affiné et la gestion des versions des modèles
-OpenAI vous fournit un ID du modèle affiné. Comme nous n'avons pas accès aux poids du modèle, `WandbLogger` crée un fichier `model_metadata.json` contenant tous les détails du modèle (hyperparamètres, ID des fichiers de données, etc.), ainsi que l'ID `fine_tuned_model``, puis l'enregistre en tant qu'Artifact W&B. +OpenAI ne rend pas accessibles les poids sous-jacents d’un modèle affiné ; W&B suit donc le modèle en capturant plutôt ses métadonnées. OpenAI vous fournit un ID du modèle affiné. Comme vous n’avez pas accès aux poids du modèle, `WandbLogger` crée un fichier `model_metadata.json` contenant tous les détails du modèle (hyperparamètres, ID des fichiers de données, etc.), ainsi que l'ID `fine_tuned_model`, puis l'enregistre en tant qu'Artifact W&B. Cet Artifact de modèle (métadonnées) peut ensuite être lié à un modèle dans le [W&B Registry](/fr/models/registry/). @@ -133,68 +137,70 @@ Cet Artifact de modèle (métadonnées) peut ensuite être lié à un modèle da ## Questions fréquentes
-
- ### Comment puis-je partager les résultats de mon fine-tuning avec mon équipe dans W&B ? +Les sections suivantes répondent aux questions courantes sur le partage, l’organisation et la récupération des runs de fine-tuning synchronisés depuis OpenAI. + +
+ ### Partagez les résultats obtenus en effectuant le fine-tuning avec votre équipe
Enregistrez vos jobs de fine-tuning sur votre compte Teams avec : ```python -WandbLogger.sync(entity="YOUR_TEAM_NAME") +WandbLogger.sync(entity="") ``` -
- ### Comment puis-je organiser mes runs ? +
+ ### Organisez vos runs
-Vos runs W&B sont automatiquement organisés et peuvent être filtrés/triés en fonction de n'importe quel paramètre de configuration, comme le type de job, le modèle de base, le taux d'apprentissage, le nom du fichier d'entraînement et tout autre hyperparamètre. +W&B organise automatiquement vos runs. Vous pouvez les filtrer et les trier en fonction de n'importe quel paramètre de configuration, comme le type de job, le modèle de base, le taux d'apprentissage, le nom du fichier d'entraînement et tout autre hyperparamètre. -De plus, vous pouvez renommer vos runs, ajouter des notes ou créer des tags pour les regrouper. +Vous pouvez également renommer vos runs, ajouter des notes ou créer des tags pour les regrouper. -Une fois que tout vous convient, vous pouvez enregistrer votre Workspace et l'utiliser pour créer un report, en important des données depuis vos runs et vos Artifacts enregistrés (fichiers d'entraînement et de validation). +Une fois que tout vous convient, enregistrez votre Workspace et utilisez-le pour créer un report, en important des données depuis vos runs et vos Artifacts enregistrés (fichiers d'entraînement et de validation). -
- ### Comment puis-je accéder à mon modèle affiné ? +
+ ### Accédez à votre modèle affiné
-L’ID du modèle affiné est enregistré dans W&B, dans les Artifacts (`model_metadata.json`), ainsi que dans la configuration. +W&B journalise l’ID du modèle affiné dans les Artifacts (`model_metadata.json`) et dans la configuration. ```python import wandb -with wandb.init(project="OpenAI-Fine-Tune", entity="YOUR_TEAM_NAME") as run: - ft_artifact = run.use_artifact("ENTITY/PROJECT/model_metadata:VERSION") +with wandb.init(project="OpenAI-Fine-Tune", entity="") as run: + ft_artifact = run.use_artifact("//model_metadata:") artifact_dir = ft_artifact.download() ``` -où `VERSION` correspond à l’un des éléments suivants : +Le paramètre fictif `` peut prendre l'une des valeurs suivantes : -* un numéro de version comme `v2` -* l’ID du fine-tuning, par exemple `ft-xxxxxxxxx` -* un alias ajouté automatiquement, comme `latest`, ou ajouté manuellement +* Un numéro de version comme `v2`. +* L'ID du fine-tuning, par exemple `ft-xxxxxxxxx`. +* Un alias ajouté automatiquement, comme `latest`, ou ajouté manuellement. -Vous pouvez ensuite accéder à l’ID de `fine_tuned_model` en lisant le fichier téléchargé `model_metadata.json`. +Vous pouvez ensuite obtenir l'ID `fine_tuned_model` en lisant le fichier `model_metadata.json` téléchargé. -
- ### Que faire si un fine-tuning ne s’est pas synchronisé correctement ? +
+ ### Récupérer un fine-tuning qui ne s’est pas synchronisé
Si un fine-tuning n’a pas été enregistré correctement dans W&B, vous pouvez utiliser `overwrite=True` et passer l’ID du job de fine-tuning : ```python WandbLogger.sync( - fine_tune_job_id="FINE_TUNE_JOB_ID", + fine_tune_job_id="", overwrite=True, ) ``` -
- ### Puis-je suivre mes jeux de données et mes modèles avec W&B ? +
+ ### Suivre les jeux de données et les modèles avec W&B
-Les données d’entraînement et de validation sont automatiquement enregistrées dans W&B sous forme d’Artifacts. Les métadonnées, y compris l’ID du modèle affiné, sont également enregistrées sous forme d’Artifacts. +W&B enregistre automatiquement les données d’entraînement et de validation sous forme d’Artifacts. W&B enregistre également les métadonnées, y compris l’ID du modèle affiné, sous forme d’Artifacts. -Vous pouvez toujours piloter le pipeline à l’aide d’API wandb de bas niveau comme `wandb.Artifact`, `wandb.Run.log`, etc. Cela vous permet d’assurer une traçabilité complète de vos données et de vos modèles. +Vous pouvez également piloter le pipeline à l’aide d’API wandb de bas niveau comme `wandb.Artifact`, `wandb.Run.log`, etc. Cela vous permet d’assurer une traçabilité complète de vos données et de vos modèles. FAQ OpenAI sur le suivi @@ -204,6 +210,8 @@ Vous pouvez toujours piloter le pipeline à l’aide d’API wandb de bas niveau ## Ressources
-* La [documentation OpenAI sur le Fine-tuning](https://platform.openai.com/docs/guides/fine-tuning/) est très complète et contient de nombreux conseils utiles -* [Colab de démonstration](https://wandb.me/openai-colab) -* [How to Fine-Tune Your OpenAI GPT-3.5 and GPT-4 Models with W&B](https://wandb.me/openai-report) Report \ No newline at end of file +Pour un contexte plus approfondi et des exemples de bout en bout, voir les ressources suivantes. + +* La [documentation OpenAI sur le Fine-tuning](https://platform.openai.com/docs/guides/fine-tuning/) pour des conseils détaillés et des astuces. +* [Colab de démonstration](https://wandb.me/openai-colab). +* [How to Fine-Tune Your OpenAI GPT-3.5 and GPT-4 Models with W&B](https://wandb.me/openai-report) Report. \ No newline at end of file diff --git a/fr/models/integrations/openai-gym.mdx b/fr/models/integrations/openai-gym.mdx index 97f034a29a..cd512d58ec 100644 --- a/fr/models/integrations/openai-gym.mdx +++ b/fr/models/integrations/openai-gym.mdx @@ -6,14 +6,16 @@ title: OpenAI Gym "L'équipe qui maintient Gym depuis 2021 a transféré tout le développement futur vers [Gymnasium](https://github.com/Farama-Foundation/Gymnasium), un remplaçant direct de Gym (import gymnasium as gym), et Gym ne recevra plus aucune mise à jour." ([Source](https://github.com/openai/gym#the-team-that-has-been-maintaining-gym-since-2021-has-moved-all-future-development-to-gymnasium-a-drop-in-replacement-for-gym-import-gymnasium-as-gym-and-gym-will-not-be-receiving-any-future-updates-please-switch-over-to-gymnasium-as-soon-as-youre-able-to-do-so-if-youd-like-to-read-more-about-the-story-behind-this-switch-please-check-out-this-blog-post)) - Comme Gym n'est plus activement maintenu, essayez notre intégration avec Gymnasium. + Comme Gym n'est plus un projet maintenu, essayez l'intégration avec Gymnasium. -Si vous utilisez [OpenAI Gym](https://github.com/openai/gym), W&B enregistre automatiquement les vidéos de votre environnement générées par `gym.wrappers.Monitor`. Définissez simplement l'argument mot-clé `monitor_gym` de [`wandb.init()`](/fr/models/ref/python/functions/init) sur `True` ou appelez `wandb.gym.monitor()`. +Cette page explique comment utiliser W&B avec [OpenAI Gym](https://github.com/openai/gym) pour capturer automatiquement des vidéos de vos environnements d'apprentissage par renforcement. Vous pouvez ensuite examiner le comportement de l'agent en parallèle des métriques de votre expérience dans W&B. -Notre intégration Gym est très légère. Nous [regardons simplement le nom du fichier vidéo](https://github.com/wandb/wandb/blob/master/wandb/integration/gym/__init__.py#L15) enregistré depuis `gym` et lui donnons ce nom, ou utilisons `"videos"` par défaut si nous ne trouvons pas de correspondance. Si vous voulez plus de contrôle, vous pouvez toujours [enregistrer une vidéo](/fr/models/track/log/media/) manuellement. +Si vous utilisez OpenAI Gym, W&B enregistre automatiquement les vidéos de votre environnement générées par `gym.wrappers.Monitor`. Pour l'activer, définissez l'argument mot-clé `monitor_gym` de [`wandb.init()`](/fr/models/ref/python/functions/init) sur `True`, ou appelez `wandb.gym.monitor()`. -Le [OpenRL Benchmark](https://wandb.me/openrl-benchmark-report) de [CleanRL](https://github.com/vwxyzjn/cleanrl) utilise cette intégration pour ses exemples OpenAI Gym. Vous pouvez trouver le code source (y compris [le code spécifique utilisé pour certains runs](https://wandb.ai/cleanrl/cleanrl.benchmark/runs/2jrqfugg/code?workspace=user-costa-huang)) qui montre comment utiliser gym avec +L'intégration gym est légère. Elle [regarde le nom du fichier vidéo](https://github.com/wandb/wandb/blob/master/wandb/integration/gym/__init__.py#L15) enregistré depuis `gym` et lui donne ce nom, ou utilise `"videos"` par défaut si elle ne trouve pas de correspondance. Si vous voulez plus de contrôle, vous pouvez [enregistrer une vidéo](/fr/models/track/log/media/) manuellement. + +Le [OpenRL Benchmark](https://wandb.me/openrl-benchmark-report) de [CleanRL](https://github.com/vwxyzjn/cleanrl) utilise cette intégration pour ses exemples OpenAI Gym. Vous pouvez trouver le code source (y compris [le code spécifique utilisé pour certains runs](https://wandb.ai/cleanrl/cleanrl.benchmark/runs/2jrqfugg/code?workspace=user-costa-huang)) qui montre comment utiliser gym avec W&B. Tableau de bord OpenAI Gym diff --git a/fr/models/integrations/paddledetection.mdx b/fr/models/integrations/paddledetection.mdx index 5db6a0a72c..ecf7ff6d84 100644 --- a/fr/models/integrations/paddledetection.mdx +++ b/fr/models/integrations/paddledetection.mdx @@ -8,13 +8,13 @@ import ApiKeyCreateStreamlined from "/snippets/fr/_includes/api-key-create-strea -[PaddleDetection](https://github.com/PaddlePaddle/PaddleDetection) est un kit de développement de détection d’objets de bout en bout basé sur [PaddlePaddle](https://github.com/PaddlePaddle/Paddle). Il détecte divers objets courants, segmente les instances, et suit et détecte les points clés à l’aide de modules configurables tels que les composants du réseau, les augmentations de données et les pertes. +[PaddleDetection](https://github.com/PaddlePaddle/PaddleDetection) est un kit de développement de détection d’objets de bout en bout basé sur [PaddlePaddle](https://github.com/PaddlePaddle/Paddle). Il détecte des objets courants, segmente les instances, et suit et détecte les points clés à l’aide de modules configurables tels que les composants du réseau, les augmentations de données et les pertes. -PaddleDetection comprend désormais une intégration W&B native qui enregistre toutes vos métriques d’entraînement et de validation, ainsi que les points de contrôle de votre modèle et leurs métadonnées associées. +PaddleDetection comprend une intégration W&B native qui enregistre toutes vos métriques d’entraînement et de validation, ainsi que les points de contrôle du modèle et leurs métadonnées associées. En suivant ce guide, vous activez le `WandbLogger` de PaddleDetection afin que W&B suive automatiquement vos expériences de détection d’objets, ce qui facilite la comparaison des Runs, le suivi de la progression et la reproduction des résultats. -Le `WandbLogger` de PaddleDetection enregistre vos métriques d’entraînement et d’évaluation dans W&B, ainsi que les points de contrôle de votre modèle pendant l’entraînement. +Le `WandbLogger` de PaddleDetection enregistre vos métriques d’entraînement et d’évaluation dans W&B, ainsi que les points de contrôle du modèle pendant l’entraînement. -[Lire un article de blog de W&B](https://wandb.ai/manan-goel/PaddleDetectionYOLOX/reports/Object-Detection-with-PaddleDetection-and-W-B--VmlldzoyMDU4MjY0) qui montre comment intégrer un modèle YOLOX à PaddleDetection sur un sous-ensemble du jeu de données `COCO2017`. +Pour un exemple détaillé, [lire un article de blog de W&B](https://wandb.ai/manan-goel/PaddleDetectionYOLOX/reports/Object-Detection-with-PaddleDetection-and-W-B--VmlldzoyMDU4MjY0) qui montre comment intégrer un modèle YOLOX à PaddleDetection sur un sous-ensemble du jeu de données `COCO2017`.
## Inscrivez-vous et créez une clé API @@ -35,7 +35,7 @@ Pour installer la bibliothèque `wandb` en local et vous connecter : - 1. Définissez la [variable d'environnement](/fr/models/track/environment-variables/) `WANDB_API_KEY` avec votre clé API. + 1. Définissez la [variable d'environnement](/fr/models/track/environment-variables/) `WANDB_API_KEY` avec votre clé API. Remplacez les valeurs entre `<>` par les vôtres : ```bash export WANDB_API_KEY= @@ -43,7 +43,7 @@ Pour installer la bibliothèque `wandb` en local et vous connecter : 2. Installez la bibliothèque `wandb` et connectez-vous. - ```shell + ```bash pip install wandb wandb login @@ -72,22 +72,24 @@ Pour installer la bibliothèque `wandb` en local et vous connecter :
- ## Activez le `WandbLogger` dans votre script d'entraînement + ## Activez `WandbLogger` dans votre script d'entraînement
+Une fois la bibliothèque `wandb` installée et votre machine authentifiée, activez `WandbLogger` pour votre tâche d'entraînement dans PaddleDetection. Vous pouvez le faire soit à l'aide d'arguments de ligne de commande, soit en modifiant votre fichier de configuration. + - Pour utiliser wandb via des arguments transmis à `train.py` dans [PaddleDetection](https://github.com/PaddlePaddle/PaddleDetection/) : + Pour utiliser `wandb` via des arguments passés à `train.py` dans [PaddleDetection](https://github.com/PaddlePaddle/PaddleDetection/) : - * Ajoutez l'option `--use_wandb` - * Les premiers arguments wandb doivent être précédés de `-o` (vous ne devez le passer qu'une seule fois) - * Chaque argument doit contenir le préfixe `"wandb-"` . Par exemple, tout argument transmis à [`wandb.init()`](/fr/models/ref/python/functions/init) recevra le préfixe `wandb-` + * Ajoutez l'indicateur `--use_wandb`. + * Le premier argument `wandb` doit être précédé de `-o` (vous ne devez l'indiquer qu'une seule fois). + * Chaque argument doit contenir le préfixe `wandb-`. Par exemple, tout argument transmis à [`wandb.init()`](/fr/models/ref/python/functions/init) reçoit le préfixe `wandb-`. - ```shell - python tools/train.py - -c config.yml \ + ```bash + python tools/train.py \ + -c config.yml \ --use_wandb \ - -o \ + -o \ wandb-project=MyDetector \ wandb-entity=MyTeam \ wandb-save_dir=./logs @@ -95,16 +97,16 @@ Pour installer la bibliothèque `wandb` en local et vous connecter : - Ajoutez les arguments wandb au fichier config.yml sous la clé `wandb` : + Vous pouvez également configurer l'intégration de manière déclarative. Ajoutez les arguments `wandb` au fichier `config.yml` sous la clé `wandb` : - ``` + ```yaml wandb: project: MyProject entity: MyTeam save_dir: ./logs ``` - Lorsque vous exécutez votre fichier `train.py`, un lien vers votre tableau de bord W&B est généré. + Lorsque vous exécutez votre fichier `train.py`, un lien vers votre tableau de bord W&B est généré. Vous pouvez y consulter en temps réel vos métriques d'entraînement et de validation, les points de contrôle du modèle et les métadonnées du run. Un tableau de bord W&B diff --git a/fr/models/integrations/paddleocr.mdx b/fr/models/integrations/paddleocr.mdx index 65ac516aa0..26b46e227f 100644 --- a/fr/models/integrations/paddleocr.mdx +++ b/fr/models/integrations/paddleocr.mdx @@ -5,13 +5,15 @@ title: PaddleOCR import ApiKeyCreateStreamlined from "/snippets/fr/_includes/api-key-create-streamlined.mdx"; -[PaddleOCR](https://github.com/PaddlePaddle/PaddleOCR) vise à créer des outils d’OCR multilingues, performants, de pointe et pratiques, afin d’aider les utilisateurs à entraîner de meilleurs modèles et à les mettre en pratique avec PaddlePaddle. PaddleOCR prend en charge un large éventail d’algorithmes de pointe liés à l’OCR et a développé des solutions industrielles. PaddleOCR propose désormais une intégration W&B pour consigner les métriques d’entraînement et d’évaluation, ainsi que les points de contrôle du modèle et les métadonnées correspondantes. +[PaddleOCR](https://github.com/PaddlePaddle/PaddleOCR) fournit des outils d’OCR multilingues et pratiques qui aident les utilisateurs à entraîner des modèles et à les déployer en production, avec une implémentation dans PaddlePaddle. PaddleOCR prend en charge une gamme d’algorithmes d’OCR et inclut des solutions industrielles. PaddleOCR inclut une intégration W&B pour la journalisation des métriques d’entraînement et d’évaluation, ainsi que des points de contrôle du modèle et des métadonnées correspondantes. -
+Cette page vous montre comment activer l’intégration W&B dans PaddleOCR afin que vos runs d’entraînement OCR transmettent automatiquement en continu les métriques, les résultats de validation et les métadonnées des points de contrôle vers un tableau de bord W&B. Utilisez cette intégration pour comparer les expériences, surveiller l’entraînement en temps réel et conserver un historique versionné de vos modèles OCR. + +
## Exemple de blog et de Colab
-[Lire ici](https://wandb.ai/manan-goel/text_detection/reports/Train-and-Debug-Your-OCR-Models-with-PaddleOCR-and-W-B--VmlldzoyMDUwMDIw) pour découvrir comment entraîner un modèle avec PaddleOCR sur le jeu de données ICDAR2015. Cet exemple inclut également un [Google Colab](https://colab.research.google.com/drive/1id2VTIQ5-M1TElAkzjzobUCdGeJeW-nV?usp=sharing), et vous pouvez consulter le tableau de bord W&B correspondant en direct [ici](https://wandb.ai/manan-goel/text_detection). Une version chinoise de ce blog est également disponible ici : [W&B对您的OCR模型进行训练和调试](https://wandb.ai/wandb_fc/chinese/reports/W-B-OCR---VmlldzoyMDk1NzE4) +Voir le [tutoriel d'entraînement PaddleOCR et W&B](https://wandb.ai/manan-goel/text_detection/reports/Train-and-Debug-Your-OCR-Models-with-PaddleOCR-and-W-B--VmlldzoyMDUwMDIw) pour découvrir comment entraîner un modèle avec PaddleOCR sur le jeu de données ICDAR2015. Cet exemple inclut également un [Google Colab](https://colab.research.google.com/drive/1id2VTIQ5-M1TElAkzjzobUCdGeJeW-nV?usp=sharing) et le [tableau de bord W&B](https://wandb.ai/manan-goel/text_detection) correspondant en direct. Une version chinoise de ce blog est également disponible : [W&B对您的OCR模型进行训练和调试](https://wandb.ai/wandb_fc/chinese/reports/W-B-OCR---VmlldzoyMDk1NzE4).
## Inscrivez-vous et créez une clé API @@ -32,7 +34,7 @@ Pour installer la bibliothèque `wandb` localement et vous connecter : - 1. Définissez la [variable d'environnement](/fr/models/track/environment-variables/) `WANDB_API_KEY` en lui attribuant votre clé API. + 1. Définissez la [variable d'environnement](/fr/models/track/environment-variables/) `WANDB_API_KEY` en lui attribuant votre clé API. Remplacez les valeurs comprises entre `<>` par les vôtres : ```bash export WANDB_API_KEY= @@ -40,7 +42,7 @@ Pour installer la bibliothèque `wandb` localement et vous connecter : 2. Installez la bibliothèque `wandb` et connectez-vous. - ```shell + ```bash pip install wandb wandb login @@ -59,7 +61,7 @@ Pour installer la bibliothèque `wandb` localement et vous connecter : - ```notebook + ```python !pip install wandb import wandb @@ -69,36 +71,36 @@ Pour installer la bibliothèque `wandb` localement et vous connecter :
- ## Ajoutez wandb à votre fichier `config.yml` + ## Ajoutez `wandb` à votre fichier `config.yml`
-PaddleOCR nécessite que les variables de configuration soient fournies dans un fichier YAML. L’ajout de l’extrait suivant à la fin du fichier de configuration YAML journalisera automatiquement toutes les métriques d’entraînement et de validation dans un tableau de bord W&B, ainsi que les points de contrôle du modèle : +PaddleOCR vous demande de fournir les variables de configuration via un fichier YAML. Pour activer la journalisation W&B, ajoutez l’extrait suivant à la fin du fichier de configuration YAML. Ce paramètre configure PaddleOCR pour journaliser automatiquement toutes les métriques d’entraînement et de validation dans un tableau de bord W&B, ainsi que les points de contrôle du modèle : -```python +```yaml Global: use_wandb: True ``` -Tout autre argument facultatif que vous souhaitez transmettre à [`wandb.init()`](/fr/models/ref/python/functions/init) peut également être ajouté dans la section `wandb` du fichier YAML : +Vous pouvez également ajouter, dans le fichier YAML, sous l’en-tête `wandb`, tous les arguments supplémentaires facultatifs que vous souhaitez transmettre à [`wandb.init()`](/fr/models/ref/python/functions/init) : -``` -wandb: - project: CoolOCR # (facultatif) c'est le nom du projet wandb - entity: my_team # (facultatif) si vous utilisez une équipe wandb, vous pouvez passer le nom de l'équipe ici - name: MyOCRModel # (facultatif) c'est le nom du run wandb +```yaml +wandb: + project: CoolOCR # (facultatif) nom du projet wandb + entity: my_team # (facultatif) si vous utilisez une équipe wandb, vous pouvez indiquer le nom de l'équipe ici + name: MyOCRModel # (facultatif) nom du run wandb ```
## Passez le fichier `config.yml` à `train.py`
-Le fichier YAML est ensuite passé en argument au [script d’entraînement](https://github.com/PaddlePaddle/PaddleOCR/blob/release/2.5/tools/train.py) disponible dans le dépôt PaddleOCR. +Une fois la journalisation W&B configurée, lancez l’entraînement en passant le fichier YAML en argument au [script d’entraînement](https://github.com/PaddlePaddle/PaddleOCR/blob/release/2.5/tools/train.py) disponible dans le dépôt PaddleOCR. ```bash python tools/train.py -c config.yml ``` -Une fois votre fichier `train.py` exécuté avec W&B activé, un lien est généré pour accéder à votre tableau de bord W&B : +Une fois votre fichier `train.py` exécuté avec W&B activé, PaddleOCR génère un lien vers votre tableau de bord W&B, où vous pouvez surveiller les métriques d’entraînement et de validation en temps réel : Tableau de bord d'entraînement PaddleOCR diff --git a/fr/models/integrations/prodigy.mdx b/fr/models/integrations/prodigy.mdx index cd6aa5e2b7..ac7b0aa86c 100644 --- a/fr/models/integrations/prodigy.mdx +++ b/fr/models/integrations/prodigy.mdx @@ -1,13 +1,13 @@ --- -description: "Intégrez W&B à Prodigy pour suivre les flux de travail d'annotation, consigner les métriques d'entraînement et gérer des Datasets étiquetés." +description: "Intégrez W&B à Prodigy pour suivre les flux de travail d'annotation, consigner les métriques d'entraînement et gérer des jeux de données étiquetés." title: Prodigy --- -[Prodigy](https://prodi.gy/) est un outil d'annotation qui permet de créer des données d'entraînement et d'évaluation pour les modèles de machine learning, ainsi que pour l'analyse des erreurs, l'inspection et le nettoyage des données. Les [W&B Tables](/fr/models/tables/tables-walkthrough/) vous permettent de consigner, visualiser, analyser et partager des Datasets (et bien plus encore !) dans W&B. +[Prodigy](https://prodi.gy/) est un outil d'annotation qui permet de créer des données d'entraînement et d'évaluation pour les modèles de machine learning, ainsi que pour l'analyse des erreurs, l'inspection et le nettoyage des données. Les [W&B Tables](/fr/models/tables/tables-walkthrough/) vous permettent de consigner, visualiser, analyser et partager des jeux de données (et bien plus encore !) dans W&B. -[L'intégration de W&B avec Prodigy](https://github.com/wandb/wandb/blob/master/wandb/integration/prodigy/prodigy.py) ajoute des fonctionnalités simples et faciles à utiliser pour téléverser directement votre jeu de données annoté avec Prodigy vers W&B afin de l'utiliser avec Tables. +Ce guide vous montre comment utiliser [l'intégration de W&B avec Prodigy](https://github.com/wandb/wandb/blob/master/wandb/integration/prodigy/prodigy.py) pour téléverser directement votre jeu de données annoté avec Prodigy vers W&B afin de pouvoir l'explorer et le partager sous forme de tableau interactif. Utilisez cette intégration si vous souhaitez inspecter la qualité des annotations, comparer les versions d'un jeu de données étiqueté ou partager les résultats avec des collaborateurs. -Exécutez quelques lignes de code, comme celles-ci : +Avec quelques lignes de code, comme celles-ci : ```python import wandb @@ -17,24 +17,22 @@ with wandb.init(project="prodigy"): upload_dataset("news_headlines_ner") ``` -et obtenez des tableaux visuels et interactifs, faciles à partager, comme celui-ci : +vous pouvez créer des tableaux visuels et interactifs, faciles à partager, comme celui-ci : tableau d’annotation Prodigy -" -
## Démarrage rapide
-Utilisez `wandb.integration.prodigy.upload_dataset` pour importer votre jeu de données Prodigy annoté directement depuis la base de données Prodigy locale vers W&B au format [Table](/fr/models/ref/python/data-types/table). Pour plus d’informations sur Prodigy, y compris l’installation et la configuration, veuillez vous référer à la [documentation Prodigy](https://prodi.gy/docs/). +Utilisez `wandb.integration.prodigy.upload_dataset` pour importer votre jeu de données Prodigy annoté directement depuis la base de données Prodigy locale vers W&B au format [tableau](/fr/models/ref/python/data-types/table). Pour plus d’informations sur Prodigy, y compris l’installation et la configuration, voir la [documentation Prodigy](https://prodi.gy/docs/). -W&B tentera automatiquement de convertir les images et les champs d’entités nommées en [`wandb.Image`](/fr/models/ref/python/data-types/image) et [`wandb.Html`](/fr/models/ref/python/data-types/html) respectivement. Des colonnes supplémentaires peuvent être ajoutées au tableau obtenu pour inclure ces visualisations. +Lorsque vous téléversez un jeu de données, W&B convertit automatiquement les images et les champs d’entités nommées en [`wandb.Image`](/fr/models/ref/python/data-types/image) et [`wandb.Html`](/fr/models/ref/python/data-types/html) respectivement, afin qu’ils s’affichent sous forme de visualisations interactives dans votre tableau. W&B peut ajouter des colonnes supplémentaires au tableau obtenu pour inclure ces visualisations.
## Lire un exemple détaillé
-Explorez [Visualiser les Datasets Prodigy avec W&B Tables](https://wandb.ai/kshen/prodigy/reports/Visualizing-Prodigy-Datasets-Using-W-B-Tables--Vmlldzo5NDE2MTc) pour découvrir des exemples de visualisations générées avec l’intégration Prodigy de W&B. \ No newline at end of file +Pour voir ce qu’il est possible de faire avec l’intégration, explorez le rapport [Visualiser les jeux de données Prodigy avec W&B Tables](https://wandb.ai/kshen/prodigy/reports/Visualizing-Prodigy-Datasets-Using-W-B-Tables--Vmlldzo5NDE2MTc) pour découvrir des exemples de visualisations générées avec l’intégration Prodigy de W&B. \ No newline at end of file diff --git a/fr/models/integrations/pytorch-geometric.mdx b/fr/models/integrations/pytorch-geometric.mdx index 724db29184..22b6e10011 100644 --- a/fr/models/integrations/pytorch-geometric.mdx +++ b/fr/models/integrations/pytorch-geometric.mdx @@ -5,7 +5,9 @@ description: "Intégrez W&B à PyTorch Geometric pour la visualisation de graphe import ApiKeyCreateStreamlined from "/snippets/fr/_includes/api-key-create-streamlined.mdx"; -[PyTorch Geometric](https://github.com/pyg-team/pytorch_geometric), ou PyG, est l’une des bibliothèques les plus populaires pour le deep learning géométrique, et W&B s’y intègre extrêmement bien pour visualiser des graphes et suivre les expériences. +[PyTorch Geometric](https://github.com/pyg-team/pytorch_geometric) (PyG) est une bibliothèque de deep learning géométrique, et W&B s’y intègre bien pour visualiser des graphes et suivre les expériences. + +Ce guide vous montre comment vous authentifier à W&B, installer la bibliothèque `wandb`, visualiser des graphes PyG avec PyVis ou Plotly, et journaliser les métriques d’entraînement de vos flux de travail PyG. Utilisez-le pour suivre les expériences et partager des visualisations de graphes dans W&B. Après avoir installé PyTorch Geometric, suivez ces étapes pour démarrer. @@ -28,7 +30,7 @@ Pour installer la bibliothèque `wandb` en local et vous connecter : - 1. Définissez la [variable d'environnement](/fr/models/track/environment-variables/) `WANDB_API_KEY` avec votre clé API. + 1. Définissez la [variable d'environnement](/fr/models/track/environment-variables/) `WANDB_API_KEY` avec votre clé API. Remplacez les valeurs entre `<>` par les vôtres : ```bash export WANDB_API_KEY= @@ -36,7 +38,7 @@ Pour installer la bibliothèque `wandb` en local et vous connecter : 2. Installez la bibliothèque `wandb` et connectez-vous. - ```shell + ```bash pip install wandb wandb login @@ -55,7 +57,7 @@ Pour installer la bibliothèque `wandb` en local et vous connecter : - ```notebook + ```python !pip install wandb import wandb @@ -65,10 +67,12 @@ Pour installer la bibliothèque `wandb` en local et vous connecter :
- ## Visualiser les graphes + ## Visualisez les graphes
-Vous pouvez enregistrer des informations sur les graphes en entrée, notamment le nombre d’arêtes, le nombre de nœuds, etc. W&B prend en charge la consignation de graphiques Plotly et de panneaux HTML, de sorte que toutes les visualisations que vous créez pour votre graphe peuvent également être consignées dans W&B. +Après vous être connecté, vous pouvez commencer à envoyer des visualisations de graphes et des données d'exécution à W&B. + +Vous pouvez enregistrer des informations sur les graphes d'entrée, notamment le nombre d'arêtes, le nombre de nœuds, etc. W&B prend en charge la journalisation des graphiques Plotly et des panneaux HTML, vous pouvez donc également journaliser dans W&B toutes les visualisations que vous créez pour votre graphe. Les sections suivantes présentent deux approches courantes : PyVis pour les visualisations HTML interactives et Plotly pour les visualisations sous forme de graphiques.
### Utiliser PyVis @@ -80,7 +84,7 @@ L’extrait suivant montre comment procéder avec PyVis et HTML. from pyvis.network import Network import wandb -with wandb.init(project=’graph_vis’) as run: +with wandb.init(project="graph_vis") as run: net = Network(height="750px", width="100%", bgcolor="#222222", font_color="white") # Ajouter les arêtes du graphe PyG au réseau PyVis @@ -99,14 +103,14 @@ with wandb.init(project=’graph_vis’) as run: ``` - Visualisation interactive de graphes + Visualisation interactive de graphe
### Utiliser Plotly
-Pour utiliser Plotly afin de créer une visualisation de graphe, vous devez d’abord convertir le graphe PyG en objet NetworkX. Vous devrez ensuite créer des graphiques de dispersion Plotly pour les nœuds et les arêtes. L’extrait ci-dessous peut être utilisé pour cette tâche. +Pour utiliser Plotly afin de créer une visualisation de graphe, convertissez d’abord le graphe PyG en objet NetworkX. Créez ensuite des graphiques de dispersion Plotly pour les nœuds et les arêtes. Utilisez l’extrait suivant pour cette tâche. ```python def create_vis(graph): @@ -151,8 +155,8 @@ def create_vis(graph): return fig -with wandb.init(project=’visualize_graph’) as run: - run.log({‘graph’: wandb.Plotly(create_vis(graph))}) +with wandb.init(project="visualize_graph") as run: + run.log({"graph": wandb.Plotly(create_vis(graph))}) ``` @@ -160,10 +164,10 @@ with wandb.init(project=’visualize_graph’) as run:
- ## Consigner des métriques + ## Journaliser des métriques
-Vous pouvez utiliser W&B pour suivre vos expériences et les métriques associées, comme les fonctions de perte, la précision, entre autres. Ajoutez la ligne suivante à votre boucle d'entraînement : +En plus des visualisations de graphe, vous pouvez utiliser W&B pour suivre vos expériences et les métriques associées, comme les fonctions de perte, la précision, entre autres. Ajoutez les lignes suivantes à votre boucle d'entraînement : ```python with wandb.init(project="my_project", entity="my_entity") as run: @@ -179,10 +183,14 @@ with wandb.init(project="my_project", entity="my_entity") as run: métriques hits@K au fil des époques +Avec les visualisations de graphes et les métriques d'entraînement journalisées dans W&B, vous pouvez comparer les runs et partager les résultats de vos expériences PyG dans votre espace de travail W&B. +
## Plus de ressources
+Les W&B Reports suivants montrent PyG en action : + * [Recommandation de produits Amazon à l’aide de réseaux neuronaux de graphes avec PyTorch Geometric](https://wandb.ai/manan-goel/gnn-recommender/reports/Recommending-Amazon-Products-using-Graph-Neural-Networks-in-PyTorch-Geometric--VmlldzozMTA3MzYw#what-does-the-data-look-like?) * [Classification de nuages de points avec PyTorch Geometric](https://wandb.ai/geekyrakshit/pyg-point-cloud/reports/Point-Cloud-Classification-using-PyTorch-Geometric--VmlldzozMTExMTE3) * [Segmentation de nuages de points avec PyTorch Geometric](https://wandb.ai/wandb/point-cloud-segmentation/reports/Point-Cloud-Segmentation-using-Dynamic-Graph-CNN--VmlldzozMTk5MDcy) \ No newline at end of file diff --git a/fr/models/integrations/pytorch.mdx b/fr/models/integrations/pytorch.mdx index 3f3f3b7160..aac7b019a7 100644 --- a/fr/models/integrations/pytorch.mdx +++ b/fr/models/integrations/pytorch.mdx @@ -17,7 +17,7 @@ Utilisez [W&B](https://wandb.ai) pour le suivi des expériences de machine l ## Ce que vous trouverez dans ce notebook
-Nous vous montrons comment intégrer W&B à votre code PyTorch pour ajouter le suivi des expériences à votre pipeline. +Ce tutoriel explique comment intégrer W&B à votre code d’entraînement PyTorch afin de pouvoir suivre les expériences, consigner des métriques et des gradients, et versionner les modèles. Utilisez-le pour ajouter le suivi des expériences à un pipeline PyTorch existant. Schéma de l’intégration entre PyTorch et W&B @@ -27,7 +27,7 @@ Nous vous montrons comment intégrer W&B à votre code PyTorch pour ajouter # importer la bibliothèque import wandb -# capturer un dictionnaire d’hyperparamètres dans la configuration +# capturer un dictionnaire d'hyperparamètres avec config config = { "learning_rate": 0.001, "epochs": 100, @@ -40,27 +40,29 @@ with wandb.init(project="new-sota-model", config=config) as run: # configurer le modèle et les données model, dataloader = get_model(), get_data() - # facultatif : suivre les gradients + # optionnel : suivre les gradients run.watch(model) for batch in dataloader: metrics = model.training_step() - # consigner des métriques dans votre boucle d’entraînement pour visualiser les performances du modèle + # consigner des métriques dans votre boucle d'entraînement pour visualiser les performances du modèle run.log(metrics) - # facultatif : enregistrer le modèle à la fin + # optionnel : sauvegarder le modèle à la fin model.to_onnx() run.save("model.onnx") ``` Suivez ce [tutoriel vidéo](https://wandb.me/pytorch-video). -**Remarque** : les sections commençant par *Étape* suffisent pour intégrer W&B à un pipeline existant. Le reste se limite à charger les données et à définir un modèle. +Les sections commençant par *Étape* suffisent pour intégrer W&B à un pipeline existant. Le reste se limite à charger les données et à définir un modèle.
## Installer, importer et se connecter
+Avant de définir l’expérience, configurez l’environnement et connectez-vous à W&B. + ```python import os import random @@ -91,24 +93,21 @@ torchvision.datasets.MNIST.mirrors = [mirror for mirror in torchvision.datasets. ### Étape 0 : Installer W&B
-Pour commencer, vous devez installer la bibliothèque. -`wandb` s’installe facilement avec `pip`. +Pour commencer, vous devez installer la bibliothèque `wandb` avec `pip`. ```python !pip install wandb onnx -Uq ``` -
+
### Étape 1 : Importer W&B et vous connecter
-Pour journaliser des données sur notre service web, -vous devrez vous connecter. +Pour journaliser des données sur le service W&B, vous devez vous connecter. -Si c'est la première fois que vous utilisez W&B, -vous devrez créer un compte gratuit via le lien qui s'affiche. +Si c'est la première fois que vous utilisez W&B, inscrivez-vous pour obtenir un compte gratuit via le lien qui s'affiche. -``` +```python import wandb wandb.login() @@ -118,25 +117,19 @@ wandb.login() ## Définir l’expérience et le pipeline
+Une fois W&B installé et votre session authentifiée, définissez la configuration de l’expérience ainsi que le pipeline d’entraînement qui l’utilisera. +
### Suivre les métadonnées et les hyperparamètres avec `wandb.init()`
-Dans le code, la première chose à faire est de définir notre expérience : -quels sont les hyperparamètres ? quelles métadonnées sont associées à ce run ? +Dans le code, commencez par définir votre expérience. Quels sont les hyperparamètres ? Quelles métadonnées sont associées à ce run ? -Il est très courant de stocker ces informations dans un dictionnaire `config` -(ou un objet similaire) -puis d'y accéder au besoin. +Une approche courante consiste à stocker ces informations dans un dictionnaire `config` (ou un objet similaire), puis à y accéder au besoin. -Dans cet exemple, nous ne faisons varier que quelques hyperparamètres -et codons le reste à la main. -Mais n'importe quelle partie de votre modèle peut faire partie de `config`. +Cet exemple ne fait varier que quelques hyperparamètres et code le reste à la main. N’importe quelle partie de votre modèle peut faire partie de `config`. -Nous incluons également quelques métadonnées : nous utilisons le jeu de données MNIST et une architecture -convolutionnelle. Si, plus tard, nous travaillons par exemple avec -des architectures entièrement connectées sur CIFAR dans le même projet, -cela nous aidera à différencier nos runs. +L’exemple inclut également des métadonnées sur le dataset MNIST et une architecture convolutionnelle. Si vous travaillez plus tard, par exemple, avec des architectures entièrement connectées sur CIFAR dans le même projet, ces métadonnées vous aideront à distinguer vos runs. ```python config = dict( @@ -149,14 +142,13 @@ config = dict( architecture="CNN") ``` -Maintenant, définissons le pipeline global, -ce qui est assez typique pour l’entraînement d’un modèle : +Ensuite, définissons le pipeline global, ce qui est assez typique pour l’entraînement d’un modèle : -1. nous commençons par `make` un modèle, ainsi que les données et l’optimiseur associés, puis -2. nous `train` le modèle en conséquence et enfin -3. nous le `test` pour voir comment l’entraînement s’est déroulé. +1. `make` un modèle, ainsi que les données et l’optimiseur associés. +2. `train` le modèle en conséquence. +3. le `test` pour voir comment l’entraînement s’est déroulé. -Nous implémenterons ces fonctions ci-dessous. +Le code suivant implémente ces fonctions. ```python def model_pipeline(hyperparameters): @@ -179,26 +171,15 @@ def model_pipeline(hyperparameters): return model ``` -La seule différence ici par rapport à un pipeline standard -est que tout se passe dans le contexte de `wandb.init()`. -L’appel à cette fonction établit un canal de communication -entre votre code et nos serveurs. +La seule différence ici par rapport à un pipeline standard est que tout se passe dans le contexte de `wandb.init()`. L’appel à cette fonction établit un canal de communication entre votre code et les serveurs de W&B. + +Le fait de passer le dictionnaire `config` à `wandb.init()` enregistre immédiatement toutes ces informations dans W&B, afin que vous sachiez toujours quelles valeurs d’hyperparamètres vous avez choisi d’utiliser pour votre expérience. -Le fait de passer le dictionnaire `config` à `wandb.init()` -enregistre immédiatement toutes ces informations, -afin que vous sachiez toujours quelles valeurs d’hyperparamètres -vous avez choisi d’utiliser pour votre expérience. +Pour vous assurer que les valeurs que vous avez choisies et enregistrées sont toujours bien celles qui sont utilisées dans votre modèle, W&B recommande d’utiliser la copie `run.config` de votre objet. Consultez la définition suivante de `make` pour voir quelques exemples. -Pour vous assurer que les valeurs que vous avez choisies et enregistrées sont toujours bien celles qui sont utilisées -dans votre modèle, nous vous recommandons d’utiliser la copie `run.config` de votre objet. -Consultez la définition de `make` ci-dessous pour voir quelques exemples. +Une fois le pipeline défini, les sections suivantes implémentent successivement chacune de ses étapes : configuration des données et du modèle, entraînement et test. -> *Remarque* : nous veillons à exécuter notre code dans des processus séparés, -> afin que tout problème de notre côté -> (par exemple, si un énorme monstre marin attaque nos centres de données) -> ne fasse pas planter votre code. -> Une fois le problème résolu, par exemple lorsque le Kraken retourne dans les profondeurs, -> vous pouvez synchroniser les données avec `wandb sync`. +> *Remarque* : W&B exécute son code dans des processus séparés afin que tout problème du côté de W&B ne fasse pas planter votre code. Une fois le problème résolu, vous pouvez synchroniser les données avec `wandb sync`. ```python def make(config): @@ -214,7 +195,7 @@ def make(config): criterion = nn.CrossEntropyLoss() optimizer = torch.optim.Adam( model.parameters(), lr=config.learning_rate) - + return model, train_loader, test_loader, criterion, optimizer ``` @@ -222,40 +203,32 @@ def make(config): ### Définir le chargement des données et le modèle
-Nous devons maintenant préciser comment les données sont chargées et à quoi ressemble le modèle. +Ensuite, précisez comment les données sont chargées et à quoi ressemble le modèle. -Cette partie est très importante, mais elle n'est -pas différente de ce qu'elle serait sans `wandb`, -donc nous ne nous y attarderons pas. +Cette partie est importante, mais elle n'est pas différente de ce qu'elle serait sans `wandb`. ```python def get_data(slice=5, train=True): full_dataset = torchvision.datasets.MNIST(root=".", - train=train, + train=train, transform=transforms.ToTensor(), download=True) - # équivalent au slicing avec [::slice] + # équivalent au slicing avec [::slice] sub_dataset = torch.utils.data.Subset( full_dataset, indices=range(0, len(full_dataset), slice)) - + return sub_dataset def make_loader(dataset, batch_size): loader = torch.utils.data.DataLoader(dataset=dataset, - batch_size=batch_size, + batch_size=batch_size, shuffle=True, pin_memory=True, num_workers=2) return loader ``` -Définir le modèle est généralement la partie la plus amusante. - -Mais rien ne change avec `wandb`, -donc nous allons nous en tenir à une architecture ConvNet standard. - -N'ayez pas peur de le modifier et d'essayer quelques expériences -- -tous vos résultats seront enregistrés sur [wandb.ai](https://wandb.ai). +Définir le modèle ne change pas avec `wandb`, donc cet exemple utilise une architecture ConvNet standard. N'ayez pas peur de le modifier et d'essayer quelques expériences -- tous vos résultats seront enregistrés sur [wandb.ai](https://wandb.ai). ```python # Réseau de neurones conventionnel et convolutif @@ -263,7 +236,7 @@ tous vos résultats seront enregistrés sur [wandb.ai](https://wandb.ai). class ConvNet(nn.Module): def __init__(self, kernels, classes=10): super(ConvNet, self).__init__() - + self.layer1 = nn.Sequential( nn.Conv2d(1, kernels[0], kernel_size=5, stride=1, padding=2), nn.ReLU(), @@ -273,7 +246,7 @@ class ConvNet(nn.Module): nn.ReLU(), nn.MaxPool2d(kernel_size=2, stride=2)) self.fc = nn.Linear(7 * 7 * kernels[-1], classes) - + def forward(self, x): out = self.layer1(x) out = self.layer2(out) @@ -286,23 +259,19 @@ class ConvNet(nn.Module): ### Définir la logique d'entraînement
-En poursuivant notre `model_pipeline`, il est temps de préciser comment nous `entraînons`. +En poursuivant dans le `model_pipeline`, il est temps de préciser comment `entraîner`. C'est là que l’intégration W&B suit les gradients, les paramètres et les métriques au fil de l’entraînement. Deux fonctions `wandb` entrent en jeu ici : `watch` et `log`.
- ## Suivre les gradients avec `run.watch()` et tout le reste avec `run.log()` + ### Suivre les gradients avec `run.watch()` et tout le reste avec `run.log()`
-`run.watch()` journalisera les gradients et les paramètres de votre modèle, -toutes les `log_freq` étapes de l'entraînement. +`run.watch()` journalisera les gradients et les paramètres de votre modèle toutes les `log_freq` étapes de l'entraînement. Appelez `run.watch()` avant de commencer l'entraînement. Pour les modes de journalisation, les modèles multiples et les conseils sur les performances, voir [Comment puis-je journaliser les gradients et les poids du modèle avec wandb.watch ?](/fr/support/models/articles/how-do-i-log-gradients-and-model-weights-with-wandb-watch). -Le reste du code d'entraînement reste le même : -nous parcourons les époques et les lots, -en effectuant des passes avant et arrière -et en appliquant notre `optimizer`. +Le reste du code d'entraînement reste le même : parcourez les époques et les lots, effectuez des passes avant et arrière, et appliquez votre `optimizer`. ```python def train(model, loader, criterion, optimizer, config): @@ -343,17 +312,11 @@ def train_batch(images, labels, model, optimizer, criterion): return loss ``` -La seule différence réside dans le code de journalisation : -alors qu’auparavant vous pouviez consigner des métriques en les affichant dans le terminal, -vous transmettez maintenant les mêmes informations à `run.log()`. +La seule différence réside dans le code de journalisation : alors qu’auparavant vous pouviez consigner des métriques en les affichant dans le terminal, vous transmettez maintenant les mêmes informations à `run.log()`. -`run.log()` attend un dictionnaire dont les clés sont des chaînes de caractères. -Ces chaînes identifient les objets enregistrés, qui constituent les valeurs. -Vous pouvez aussi indiquer, de façon facultative, à quelle `step` d’entraînement vous en êtes. +`run.log()` attend un dictionnaire dont les clés sont des chaînes de caractères. Ces chaînes identifient les objets enregistrés, qui constituent les valeurs. Vous pouvez aussi indiquer, de façon facultative, à quelle `step` d’entraînement vous en êtes. -> *Remarque* : j’aime utiliser le nombre d’exemples que le modèle a vus, -> car cela facilite la comparaison entre différentes tailles de lot, -> mais vous pouvez utiliser les étapes brutes ou le nombre de lots. Pour des runs d’entraînement plus longs, il peut aussi être pertinent de journaliser par `epoch`. +> *Remarque* : utiliser le nombre d’exemples que le modèle a vus facilite la comparaison entre différentes tailles de lot, mais vous pouvez utiliser les étapes brutes ou le nombre de lots. Pour des runs d’entraînement plus longs, il peut aussi être pertinent de journaliser par `epoch`. ```python def train_log(loss, example_ct, epoch): @@ -368,17 +331,15 @@ def train_log(loss, example_ct, epoch): ### Définir la logique de test
-Une fois l'entraînement du modèle terminé, nous voulons le tester : -l'exécuter sur de nouvelles données issues de la Production, par exemple, -ou l'appliquer à des exemples soigneusement sélectionnés à la main. +Une fois l’entraînement du modèle terminé, testez-le : exécutez-le sur de nouvelles données de production, par exemple, ou appliquez-le à des exemples soigneusement sélectionnés à la main. Les tests vous offrent également un moment naturel pour enregistrer le modèle entraîné.
- ## (Facultatif) Appelez `run.save()` + ### Facultatif : Appelez `run.save()`
C’est aussi le bon moment pour enregistrer l’architecture du modèle et les paramètres finaux sur le disque. -Pour une compatibilité maximale, nous allons `exporter` notre modèle au +Pour une compatibilité étendue, `exportez` le modèle au format [Open Neural Network eXchange (ONNX)](https://onnx.ai/). En passant ce nom de fichier à `run.save()`, vous vous assurez que les paramètres du modèle @@ -386,7 +347,7 @@ sont enregistrés sur les serveurs de W&B : fini les pertes de repères pou correspond à quel run d’entraînement. Pour des fonctionnalités `wandb` plus avancées pour le stockage, la gestion des versions et la distribution de -modèles, consultez nos [outils Artifacts](https://www.wandb.com/artifacts). +modèles, consultez les [outils Artifacts](https://www.wandb.com/artifacts). ```python def test(model, test_loader): @@ -405,7 +366,7 @@ def test(model, test_loader): print(f"Accuracy of the model on the {total} " + f"test images: {correct / total:%}") - + run.log({"test_accuracy": correct / total}) # Enregistrer le modèle au format ONNX interopérable @@ -414,27 +375,21 @@ def test(model, test_loader): ```
- ### Exécutez l’entraînement et suivez vos métriques en direct sur wandb.ai + ### Exécutez l'entraînement et regardez vos métriques en direct sur wandb.ai
-Maintenant que nous avons défini l’ensemble du pipeline et ajouté -ces quelques lignes de code W&B, -nous sommes prêts à lancer notre expérience avec un suivi complet. +Maintenant que vous avez défini l'ensemble du pipeline et ajouté ces quelques lignes de code W&B, vous êtes prêt à exécuter votre expérience avec un suivi complet. -Nous vous fournirons quelques liens : -notre documentation, -la page du projet, qui organise tous les runs d’un projet, et -la page du run, où les résultats de ce run seront stockés. +W&B affiche quelques liens : la documentation, la page Project (qui organise tous les runs d'un project) et la page Run (où sont stockés les résultats de ce run). -Accédez à la page du run et consultez ces onglets : +Accédez à la page Run et consultez les onglets suivants : -1. **Charts**, où les gradients du modèle, les valeurs des paramètres et la perte sont enregistrés tout au long de l’entraînement -2. **System**, qui contient diverses métriques système, notamment l’utilisation des E/S du disque, les métriques CPU et GPU (regardez cette température grimper), et bien plus encore -3. **Logs**, qui contient une copie de tout ce qui a été envoyé vers la sortie standard pendant l’entraînement -4. **Files**, où, une fois l’entraînement terminé, vous pouvez cliquer sur `model.onnx` pour visualiser notre réseau avec le [visualiseur de modèles Netron](https://github.com/lutzroeder/netron). +1. **Charts**, où les gradients du modèle, les valeurs des paramètres et la perte sont enregistrés tout au long de l'entraînement. +2. **System**, qui contient les métriques système, y compris l'utilisation des E/S disque ainsi que les métriques CPU et GPU. +3. **Logs**, qui contient une copie de tout ce qui a été envoyé sur la sortie standard pendant l'entraînement. +4. **Files**, où, une fois l'entraînement terminé, vous pouvez cliquer sur `model.onnx` pour visualiser votre réseau avec le [visualiseur de modèles Netron](https://github.com/lutzroeder/netron). -Une fois le run terminé, à la sortie du bloc `with wandb.init()`, -nous afficherons également un résumé des résultats dans la sortie de la cellule. +Une fois le run terminé, à la fin du bloc `with wandb.init()`, W&B affiche également une synthèse des résultats dans la sortie de la cellule. ```python # Construire, entraîner et analyser le modèle avec le pipeline @@ -442,44 +397,40 @@ model = model_pipeline(config) ```
- ### Tester des hyperparamètres avec Sweeps + ### Tester des hyperparamètres avec des balayages
-Dans cet exemple, nous n’avons examiné qu’un seul ensemble d’hyperparamètres. -Or, une part importante de la plupart des flux de travail de ML consiste à itérer sur -plusieurs hyperparamètres. - -Vous pouvez utiliser W&B Sweeps pour automatiser les tests d’hyperparamètres et explorer l’espace des modèles possibles ainsi que les stratégies d’optimisation. +Cet exemple ne portait que sur un seul ensemble d’hyperparamètres. Or, dans la plupart des flux de travail de ML, il est essentiel de faire varier plusieurs hyperparamètres. -Consultez un [notebook Colab montrant l’optimisation des hyperparamètres avec W&B Sweeps](https://wandb.me/sweeps-colab). +Vous pouvez utiliser les balayages W&B pour automatiser les tests d’hyperparamètres et explorer l’espace des modèles et des stratégies d’optimisation possibles. Cela vous permet d’aller au-delà de l’exécution précédente à configuration unique. -Exécuter un balayage d’hyperparamètres avec W&B est très simple. Il n’y a que 3 étapes : +Consultez ce [notebook Colab montrant l’optimisation d’hyperparamètres avec les balayages W&B](https://wandb.me/sweeps-colab). -1. **Définir le balayage :** pour cela, créez un dictionnaire ou un [fichier YAML](/fr/models/sweeps/define-sweep-configuration/) qui spécifie les paramètres à explorer, la stratégie de recherche, la métrique d’optimisation, etc. +L’exécution d’un balayage d’hyperparamètres avec W&B se déroule en trois étapes : -2. **Initialiser le balayage :** - `sweep_id = wandb.sweep(sweep_config)` - -3. **Exécuter l’agent de balayage :** - `wandb.agent(sweep_id, function=train)` +1. **Définir le balayage :** créez un dictionnaire ou un [fichier YAML](/fr/models/sweeps/define-sweep-configuration/) qui spécifie les paramètres à explorer, la stratégie de recherche, la métrique d’optimisation, etc. +2. **Initialiser le balayage :** `sweep_id = wandb.sweep(sweep_config)`. +3. **Exécuter l’agent de balayage :** `wandb.agent(sweep_id, function=train)`. C’est tout ce qu’il faut pour exécuter un balayage d’hyperparamètres. - Tableau de bord d’entraînement PyTorch + tableau de bord d’entraînement PyTorch -Explorez des exemples de projets suivis et visualisés avec W&B dans notre [Galerie →](https://app.wandb.ai/gallery). +Explorez des exemples de projets suivis et visualisés avec W&B dans la [Galerie](https://app.wandb.ai/gallery).
## Configuration avancée
-1. [Variables d’environnement](/fr/platform/hosting/env-vars/) : définissez des clés API dans les variables d’environnement pour pouvoir lancer des entraînements sur un cluster géré. -2. [Mode hors ligne](/fr/support/models/articles/how-do-i-run-wandb-offline) : utilisez le mode `dryrun` pour entraîner hors ligne et synchroniser les résultats plus tard. -3. [Sur site](/fr/platform/hosting/hosting-options/self-managed) : installez W&B dans un cloud privé ou sur des serveurs isolés du réseau au sein de votre propre infrastructure. Nous proposons des déploiements locaux pour tous les profils, du monde universitaire aux équipes d’entreprise. -4. [Sweeps](/fr/models/sweeps/) : configurez rapidement une recherche d'hyperparamètres avec notre outil léger de réglage. \ No newline at end of file +Les options suivantes peuvent étendre le flux de travail de base précédent pour les environnements de production, hors ligne ou gérés : + +* [Variables d’environnement](/fr/platform/hosting/env-vars/) : définissez des clés API dans les variables d’environnement pour pouvoir lancer des entraînements sur un cluster géré. +* [Mode hors ligne](/fr/support/models/articles/how-do-i-run-wandb-offline) : utilisez le mode `dryrun` pour entraîner hors ligne et synchroniser les résultats plus tard. +* [Sur site](/fr/platform/hosting/hosting-options/self-managed) : installez W&B dans un cloud privé ou sur des serveurs isolés du réseau au sein de votre propre infrastructure. +* [Sweeps](/fr/models/sweeps/) : configurez rapidement une recherche d'hyperparamètres avec un outil léger de réglage. \ No newline at end of file diff --git a/fr/models/integrations/ray-tune.mdx b/fr/models/integrations/ray-tune.mdx index 9760f6c6f6..469f13eaaf 100644 --- a/fr/models/integrations/ray-tune.mdx +++ b/fr/models/integrations/ray-tune.mdx @@ -1,41 +1,39 @@ --- -description: "Intégrez W&B à Ray Tune pour suivre les essais de réglage des hyperparamètres, consigner des métriques et comparer les résultats des expériences." +description: "Intégrez W&B à Ray Tune pour suivre les essais d'optimisation d'hyperparamètres, consigner des métriques et comparer les résultats des expériences." title: Ray Tune --- -W&B s’intègre à [Ray](https://github.com/ray-project/ray) en proposant deux intégrations légères. +Cette page explique comment utiliser W&B avec [Ray](https://github.com/ray-project/ray) Tune afin de suivre les essais d'optimisation d'hyperparamètres, de consigner des métriques et de comparer les résultats des expériences d'une exécution à l'autre. W&B propose deux intégrations légères avec Ray, et vous pouvez choisir celle qui correspond le mieux à votre flux de travail d'entraînement : -* La fonction `WandbLoggerCallback` consigne automatiquement dans l’API Wandb les métriques transmises à Tune. -* La fonction `setup_wandb()`, qui peut être utilisée avec l’API fonctionnelle, initialise automatiquement l’API Wandb avec les informations d’entraînement de Tune. Vous pouvez utiliser l’API Wandb comme d’habitude, par exemple avec `run.log()` pour consigner votre entraînement. +* La fonction `WandbLoggerCallback` journalise automatiquement dans W&B les métriques transmises à Tune. +* La fonction `setup_wandb()`, que vous pouvez utiliser avec l'API fonctionnelle, initialise automatiquement le SDK Python W&B (`wandb`) avec les informations d'entraînement de Tune. Vous pouvez utiliser l'API W&B comme d'habitude, par exemple en appelant `run.log()` pour journaliser votre entraînement.
## Configurer l’intégration
+Cette section explique comment configurer `WandbLoggerCallback`, qui constitue le moyen le plus direct d’envoyer les métriques des essais Tune à W&B. + ```python from ray.air.integrations.wandb import WandbLoggerCallback ``` -La configuration de wandb s’effectue en passant une clé `wandb` au paramètre `config` de `tune.run()` (voir l’exemple ci-dessous). - -Le contenu de l’entrée de configuration `wandb` est transmis à `wandb.init()` sous forme d’arguments nommés. Exception faite des paramètres suivants, qui servent à configurer `WandbLoggerCallback` lui-même : +Pour configurer W&B, fournissez une clé wandb au paramètre `config` de `tune.run()`. Voir l’[exemple](#example) pour savoir comment l’utiliser. +L’intégration transmet le contenu de l’entrée de configuration wandb à `wandb.init()` sous forme d’arguments nommés. Les seules exceptions sont les paramètres qui configurent `WandbLoggerCallback` lui-même.
### Paramètres
-`project (str)`: Nom du projet wandb. Obligatoire. - -`api_key_file (str)`: Chemin du fichier contenant la clé API wandb. - -`api_key (str)`: Clé API wandb. Alternative à `api_key_file`. +Le `WandbLoggerCallback` accepte les paramètres suivants : -`excludes (list)`: Liste des métriques à exclure du journal. - -`log_config (bool)`: Indique s'il faut journaliser le paramètre de configuration du dictionnaire de résultats. Valeur par défaut : False. - -`upload_checkpoints (bool)`: Si True, les points de contrôle du modèle sont téléversés en tant qu'Artifacts. Valeur par défaut : False. +* `project (str)` : Nom du projet W&B. Requis. +* `api_key_file (str)` : Chemin vers le fichier contenant la clé API W&B. +* `api_key (str)` : Clé API W&B. Alternative à `api_key_file`. +* `excludes (list)` : Liste des métriques à exclure du journal. +* `log_config (bool)` : Indique s’il faut journaliser le paramètre `config` du dictionnaire de résultats. Par défaut : `False`. +* `upload_checkpoints (bool)` : Si `True`, téléverse les points de contrôle du modèle en tant qu’artefacts. Par défaut : `False`.
### Exemple @@ -74,11 +72,13 @@ results = tuner.fit() ## setup_wandb
+Utilisez `setup_wandb()` lorsque vous souhaitez contrôler directement la journalisation W&B depuis votre fonction d’entraînement, par exemple pour appeler `run.log()` avec des métriques personnalisées aux côtés du reporting de Tune. + ```python from ray.air.integrations.wandb import setup_wandb ``` -Cette fonction utilitaire permet d’initialiser wandb pour l’utiliser avec Ray Tune. Pour une utilisation de base, appelez `setup_wandb()` dans votre fonction d’entraînement : +Cette fonction utilitaire permet d’initialiser W&B pour l’utiliser avec Ray Tune. Pour une utilisation de base, appelez `setup_wandb()` dans votre fonction d’entraînement : ```python from ray import tune @@ -117,7 +117,7 @@ results = tuner.fit() ## Exemple de code
-Nous avons créé quelques exemples pour vous montrer comment fonctionne l’intégration : +Pour des références complètes, consultez les exemples suivants, qui montrent comment fonctionne l’intégration : -* [Colab](https://wandb.me/raytune-colab) : Une démo simple pour essayer l’intégration. -* [Dashboard](https://wandb.ai/anmolmann/ray_tune) : Consultez le tableau de bord généré à partir de cet exemple. \ No newline at end of file +* [Essayez l’intégration dans Colab](https://wandb.me/raytune-colab) : une démo pour essayer l’intégration. +* [Voir le tableau de bord de l’exemple](https://wandb.ai/anmolmann/ray_tune) : voir le tableau de bord généré à partir de l’exemple. \ No newline at end of file diff --git a/fr/models/integrations/sagemaker.mdx b/fr/models/integrations/sagemaker.mdx index 6e009336f0..221cfedb7b 100644 --- a/fr/models/integrations/sagemaker.mdx +++ b/fr/models/integrations/sagemaker.mdx @@ -3,37 +3,37 @@ description: "Intégrez W&B à Amazon SageMaker pour le suivi des expériences, title: SageMaker --- -W&B s’intègre à [Amazon SageMaker](https://aws.amazon.com/sagemaker/) et lit automatiquement les hyperparamètres, regroupe les Runs distribués et reprend les runs à partir des checkpoints. +W&B s’intègre à [Amazon SageMaker](https://aws.amazon.com/sagemaker/) pour lire automatiquement les hyperparamètres, regrouper les Runs distribués et reprendre les runs à partir des checkpoints.
## Authentification
-W&B recherche un fichier nommé `secrets.env` dans le même répertoire que le script d'entraînement et charge son contenu dans l'environnement lorsque `wandb.init()` est appelé. Vous pouvez générer un fichier `secrets.env` en appelant `wandb.sagemaker_auth(path="source_dir")` dans le script que vous utilisez pour lancer vos expériences. Veillez à ajouter ce fichier à votre `.gitignore` ! +W&B recherche un fichier nommé `secrets.env` dans le même répertoire que le script d'entraînement et charge son contenu dans l'environnement lorsque vous appelez `wandb.init()`. Pour générer un fichier `secrets.env`, appelez `wandb.sagemaker_auth(path="source_dir")` dans le script que vous utilisez pour lancer vos expériences. Ajoutez ce fichier à votre `.gitignore`.
## Estimateurs existants
-Si vous utilisez l’un des estimateurs préconfigurés de SageMaker, vous devez ajouter un fichier `requirements.txt` à votre répertoire source, incluant wandb +Si vous utilisez l’un des estimateurs préconfigurés de SageMaker, ajoutez un fichier `requirements.txt` à votre répertoire source contenant `wandb` : ```text wandb ``` -Si vous utilisez un estimateur qui s’exécute sous Python 2, vous devrez installer `psutil` directement depuis ce [wheel](https://pythonwheels.com) avant d’installer wandb : +Si vous utilisez un estimateur qui fonctionne avec Python 2, installez `psutil` depuis cette [wheel](https://pythonwheels.com) avant d’installer `wandb` : ```text https://wheels.galaxyproject.org/packages/psutil-5.4.8-cp27-cp27mu-manylinux1_x86_64.whl wandb ``` -Consultez un exemple complet sur [GitHub](https://github.com/wandb/examples/tree/master/examples/pytorch/pytorch-cifar10-sagemaker) et lisez-en plus sur notre [blog](https://wandb.ai/site/articles/running-sweeps-with-sagemaker). +Pour un exemple complet, voir l’[exemple SageMaker sur GitHub](https://github.com/wandb/examples/tree/master/examples/pytorch/pytorch-cifar10-sagemaker). Pour en savoir plus sur l’exécution de Sweeps avec SageMaker, voir l’[article de blog W&B sur les Sweeps avec SageMaker](https://wandb.ai/site/articles/running-sweeps-with-sagemaker). -Vous pouvez également consulter le tutoriel [Deploy Sentiment Analyzer Using SageMaker and W&B](https://wandb.ai/authors/sagemaker/reports/Deploy-Sentiment-Analyzer-Using-SageMaker-and-W-B--VmlldzoxODA1ODE) sur le déploiement d'un analyseur de sentiments avec SageMaker et W&B. +Pour obtenir un tutoriel sur le déploiement d’un analyseur de sentiment avec SageMaker et W&B, voir [Deploy Sentiment Analyzer Using SageMaker and W&B](https://wandb.ai/authors/sagemaker/reports/Deploy-Sentiment-Analyzer-Using-SageMaker-and-W-B--VmlldzoxODA1ODE). - L'agent de sweep W&B se comporte comme prévu dans un job SageMaker uniquement si votre intégration SageMaker est désactivée. Désactivez l'intégration SageMaker en modifiant votre appel à `wandb.init()` : + L’agent de balayage W&B fonctionne correctement dans un job SageMaker uniquement lorsque l’intégration SageMaker est désactivée. Pour désactiver l’intégration SageMaker, mettez à jour votre appel à `wandb.init()` : ```python wandb.init(..., settings=wandb.Settings(sagemaker_disable=True)) diff --git a/fr/models/integrations/scikit.mdx b/fr/models/integrations/scikit.mdx index 7e77696ed8..8d0aa2e6df 100644 --- a/fr/models/integrations/scikit.mdx +++ b/fr/models/integrations/scikit.mdx @@ -5,7 +5,7 @@ description: "Utilisez W&B pour visualiser et comparer les performances des mod import ApiKeyCreateStreamlined from "/snippets/fr/_includes/api-key-create-streamlined.mdx"; -Vous pouvez utiliser wandb pour visualiser et comparer les performances de vos modèles scikit-learn en quelques lignes de code seulement. [Essayez un exemple →](https://wandb.me/scikit-colab) +Cette page vous montre comment utiliser W&B pour suivre les expériences et enregistrer automatiquement des graphiques qui visualisent et comparent les performances des modèles. Vous pouvez utiliser le SDK Python W&B (`wandb`) pour visualiser et comparer les performances de vos modèles scikit-learn en quelques lignes de code seulement. [Essayez un exemple](https://wandb.me/scikit-colab).
## Bien démarrer @@ -30,7 +30,7 @@ Pour installer la bibliothèque `wandb` localement et vous connecter : - 1. Définissez la [variable d'environnement](/fr/models/track/environment-variables/) `WANDB_API_KEY` avec votre clé API. + 1. Définissez la [variable d'environnement](/fr/models/track/environment-variables/) `WANDB_API_KEY` avec votre clé API. Remplacez les valeurs entre `<>` par les vôtres : ```bash export WANDB_API_KEY= @@ -70,6 +70,8 @@ Pour installer la bibliothèque `wandb` localement et vous connecter : ### Journalisation des métriques
+Après l'installation et la connexion, consignez des métriques depuis votre code d'entraînement scikit-learn pour pouvoir comparer les runs dans W&B. + ```python import wandb @@ -89,8 +91,10 @@ with wandb.init(project="visualize-sklearn") as run: ### Créer des graphiques
-
- #### Étape 1 : Importez wandb et initialisez un nouveau run +En plus de consigner des métriques, vous pouvez générer des graphiques de diagnostic pour vos modèles scikit-learn et les consigner dans un run. Les étapes suivantes initialisent un run, puis affichent soit des graphiques individuels, soit un ensemble complet de graphiques pour un type de modèle donné. + +
+ #### Importez wandb et initialisez un nouveau run
```python @@ -99,15 +103,17 @@ import wandb run = wandb.init(project="visualize-sklearn") ``` -
- #### Étape 2 : Visualiser les graphiques +
+ #### Visualiser les graphiques
+Les sections suivantes expliquent comment visualiser des graphiques individuels ou l’ensemble des graphiques pour un type de modèle donné. +
- #### Graphiques individuels + ##### Graphiques individuels
-Après avoir entraîné un modèle et effectué des prédictions, vous pouvez générer des graphiques dans wandb pour analyser ces prédictions. Voir la section **Graphiques pris en charge** ci-dessous pour obtenir la liste complète des graphiques pris en charge. +Après avoir entraîné un modèle et effectué des prédictions, vous pouvez générer des graphiques dans W&B pour analyser ces prédictions. Pour plus d’informations sur les graphiques pris en charge, voir la section **Graphiques pris en charge**. ```python # Visualiser un graphique individuel @@ -115,7 +121,7 @@ wandb.sklearn.plot_confusion_matrix(y_true, y_pred, labels) ```
- #### Tous les graphiques + ##### Tous les graphiques
W&B propose des fonctions telles que `plot_classifier`, qui permettent d'afficher plusieurs graphiques pertinents : @@ -150,13 +156,13 @@ run.finish() #### Graphiques Matplotlib existants
-Les graphiques créés avec Matplotlib peuvent également être enregistrés sur le tableau de bord W&B. Pour cela, vous devez d'abord installer `plotly`. +Si vous créez déjà des graphiques avec Matplotlib, vous pouvez également les enregistrer dans le tableau de bord W&B, à côté de vos graphiques scikit-learn. Pour cela, vous devez d'abord installer `plotly`. ```bash pip install plotly ``` -Enfin, vous pouvez enregistrer les graphiques dans le tableau de bord de W&B comme suit : +Enfin, enregistrez les graphiques dans le tableau de bord de W&B comme suit : ```python import matplotlib.pyplot as plt @@ -175,6 +181,8 @@ with wandb.init(project="visualize-sklearn") as run: ## Graphiques pris en charge
+Les sections suivantes décrivent chaque type de graphique que `wandb.sklearn` peut produire, ainsi que la signature de fonction et les arguments correspondants. Utilisez-les comme référence lorsque vous appelez des fonctions de graphique spécifiques ou interprétez la sortie de `plot_classifier`, `plot_regressor` et `plot_clusterer`. +
### Courbe d'apprentissage
@@ -199,13 +207,13 @@ Entraîne un modèle sur des jeux de données de tailles variables et génère u Courbe ROC de Scikit-learn -Les courbes ROC représentent le taux de vrais positifs (axe y) par rapport au taux de faux positifs (axe x). Le score idéal est un TPR = 1 et un FPR = 0, ce qui correspond au point situé en haut à gauche. En général, on calcule l’aire sous la courbe ROC (AUC-ROC), et plus l’AUC-ROC est élevée, mieux c’est. +Les courbes ROC représentent le taux de vrais positifs (axe y) par rapport au taux de faux positifs (axe x). Le score idéal est un TPR = 1 et un FPR = 0, ce qui correspond au point situé en haut à gauche. Vous calculez l’aire sous la courbe ROC (AUC-ROC), et plus l’AUC-ROC est élevée, mieux c’est. `wandb.sklearn.plot_roc(y_true, y_probas, labels)` * y_true (arr): Étiquettes de l’ensemble de test. * y_probas (arr): Probabilités prédites pour l’ensemble de test. -* labels (list): Libellés des classes pour la variable cible (y). +* labels (list): étiquette nommé de la variable cible (y)
### Proportions des classes @@ -233,13 +241,13 @@ Trace la répartition des classes cibles dans les ensembles d'entraînement Calcule le compromis entre la précision et le rappel pour différents seuils. Une grande aire sous la courbe indique à la fois un rappel élevé et une précision élevée, où une précision élevée correspond à un faible taux de faux positifs, et un rappel élevé à un faible taux de faux négatifs. -Des scores élevés pour les deux montrent que le classifieur renvoie des résultats précis (précision élevée) et qu'il identifie la majorité des cas positifs (rappel élevé). La courbe PR est utile lorsque les classes sont très déséquilibrées. +Des scores élevés pour les deux montrent que le classifieur renvoie des résultats précis (précision élevée) et qu'il identifie la majorité des cas positifs (rappel élevé). La courbe précision-rappel est utile lorsque les classes sont déséquilibrées. `wandb.sklearn.plot_precision_recall(y_true, y_probas, labels)` * y_true (arr): Étiquettes de l'ensemble de test. * y_probas (arr): Probabilités prédites sur l'ensemble de test. -* labels (list): Noms des étiquettes pour la variable cible (y). +* labels (list): étiquette nommé de la variable cible (y)
### Importance des fonctionnalités @@ -251,7 +259,7 @@ Des scores élevés pour les deux montrent que le classifieur renvoie des résul Évalue et trace l’importance de chaque fonctionnalité pour la tâche de classification. Fonctionne uniquement avec les classifieurs qui possèdent un attribut `feature_importances_`, comme les arbres. -`wandb.sklearn.plot_feature_importances(model, ['width', 'height, 'length'])` +`wandb.sklearn.plot_feature_importances(model, ['width', 'height', 'length'])` * model (clf): Prend en entrée un classifieur ajusté. * feature_names (list): Noms des fonctionnalités. Rend les graphiques plus lisibles en remplaçant les indices des fonctionnalités par les noms correspondants. @@ -266,7 +274,7 @@ Des scores élevés pour les deux montrent que le classifieur renvoie des résul Montre dans quelle mesure les probabilités prédites d’un classifieur sont bien calibrées et comment calibrer un classifieur non calibré. Compare les probabilités prédites estimées par un modèle de régression logistique de référence, le modèle passé en argument, ainsi que ses calibrations isotone et sigmoïde. -Plus les courbes de calibration sont proches de la diagonale, mieux c’est. Une courbe en sigmoïde inversée représente un classifieur surajusté, tandis qu’une courbe en sigmoïde représente un classifieur sous-ajusté. En entraînant les calibrations isotone et sigmoïde du modèle et en comparant leurs courbes, nous pouvons déterminer si le modèle est en surajustement ou en sous-ajustement et, le cas échéant, quelle calibration (sigmoïde ou isotone) pourrait aider à corriger le problème. +Plus les courbes de calibration sont proches de la diagonale, mieux c’est. Une courbe en sigmoïde inversée représente un classifieur surajusté, tandis qu’une courbe en sigmoïde représente un classifieur sous-ajusté. En entraînant les calibrations isotone et sigmoïde du modèle et en comparant leurs courbes, vous pouvez déterminer si le modèle est en surajustement ou en sous-ajustement et, le cas échéant, quelle calibration (sigmoïde ou isotone) pourrait aider à corriger le problème. Pour plus de détails, consultez [la documentation de sklearn](https://scikit-learn.org/stable/auto_examples/calibration/plot_calibration_curve.html). @@ -275,7 +283,7 @@ Pour plus de détails, consultez [la documentation de sklearn](https://scikit-le * model (clf) : Prend en entrée un classifieur ajusté. * X (arr) : Fonctionnalités de l’ensemble d’entraînement. * y (arr) : Étiquettes de l’ensemble d’entraînement. -* model_name (str) : Nom du modèle. Valeur par défaut : 'Classifier' +* model_name (str) : Nom du modèle. Valeur par défaut : `"Classifier"`.
### Matrice de confusion @@ -285,7 +293,7 @@ Pour plus de détails, consultez [la documentation de sklearn](https://scikit-le Matrice de confusion Scikit-learn -Calcule la matrice de confusion pour évaluer la précision d'une classification. Elle est utile pour évaluer la qualité des prédictions du modèle et repérer des tendances dans les prédictions pour lesquelles le modèle se trompe. La diagonale représente les prédictions que le modèle a correctement faites, c'est-à-dire lorsque l'étiquette réelle est égale à l'étiquette prédite. +Calcule la matrice de confusion pour évaluer la précision d'une classification. Elle est utile pour évaluer la qualité des prédictions du modèle et repérer des tendances dans les prédictions incorrectes. La diagonale représente les prédictions pour lesquelles l'étiquette réelle est égale à l'étiquette prédite. `wandb.sklearn.plot_confusion_matrix(y_true, y_pred, labels)` @@ -309,7 +317,7 @@ Calcule la matrice de confusion pour évaluer la précision d'une classifica * model (clf or reg): Prend en entrée un régresseur ou un classifieur ajusté. * X (arr): Fonctionnalités de l’ensemble d’entraînement. * y (arr): Étiquettes de l’ensemble d’entraînement. - * X_test (arr): Fonctionnalités de l’ensemble de test. +* X_test (arr): Fonctionnalités de l’ensemble de test. * y_test (arr): Étiquettes de l’ensemble de test.
@@ -337,15 +345,15 @@ Mesure et représente le pourcentage de variance expliquée en fonction du nombr Mesure et représente graphiquement à quel point chaque point d’un cluster est proche des points des clusters voisins. L’épaisseur des clusters correspond à leur taille. La ligne verticale représente le score de silhouette moyen de tous les points. -Des coefficients de silhouette proches de +1 indiquent que l’échantillon est très éloigné des clusters voisins. Une valeur de 0 indique que l’échantillon se trouve sur, ou très près de, la frontière de décision entre deux clusters voisins, et des valeurs négatives indiquent que ces échantillons ont pu être assignés au mauvais cluster. +Des coefficients de silhouette proches de +1 indiquent que l’échantillon est très éloigné des clusters voisins. Une valeur de 0 indique que l’échantillon se trouve sur, ou près de, la frontière de décision entre deux clusters voisins, et des valeurs négatives indiquent que ces échantillons ont pu être assignés au mauvais cluster. -En général, on cherche à ce que tous les scores de silhouette des clusters soient supérieurs à la moyenne (au-delà de la ligne rouge) et aussi proches que possible de 1. On préfère également des tailles de cluster qui reflètent les structures sous-jacentes des données. +Vous souhaitez que tous les scores de silhouette des clusters soient supérieurs à la moyenne (au-delà de la ligne rouge) et aussi proches que possible de 1. Vous préférez également des tailles de cluster qui reflètent les structures sous-jacentes des données. `wandb.sklearn.plot_silhouette(model, X_train, ['spam', 'not spam'])` -* model (clusterer) : Prend en entrée un algorithme de clustering ajusté. +* model (clusterer) : Prend en entrée un clusterer ajusté. * X (arr) : Fonctionnalités de l’ensemble d’entraînement. - * cluster_labels (list) : Noms des étiquettes de cluster. Rend les graphiques plus faciles à lire en remplaçant les indices de cluster par les noms correspondants. +* cluster_labels (list) : Noms des étiquettes de cluster. Rend les graphiques plus faciles à lire en remplaçant les indices de cluster par les noms correspondants.
### Graphique des valeurs aberrantes potentielles @@ -355,11 +363,11 @@ En général, on cherche à ce que tous les scores de silhouette des clusters so Graphique des valeurs aberrantes de Scikit-learn -Mesure l'influence d'un point de données sur un modèle de régression à l'aide de la distance de Cook. Les instances dont l'influence est fortement disproportionnée peuvent être des valeurs aberrantes potentielles. Utile pour la détection des valeurs aberrantes. +Mesure l'influence d'un point de données sur un modèle de régression à l'aide de la distance de Cook. Les instances dont l'influence est fortement disproportionnée peuvent être des valeurs aberrantes. Utile pour la détection des valeurs aberrantes. `wandb.sklearn.plot_outlier_candidates(model, X, y)` -* model (regressor): Accepte un classificateur ajusté. +* model (regressor): Accepte un classifieur ajusté. * X (arr): Fonctionnalités de l’ensemble d’entraînement. * y (arr): Étiquettes de l’ensemble d’entraînement. @@ -373,7 +381,7 @@ Mesure l'influence d'un point de données sur un modèle de régression Mesure et représente les valeurs cibles prédites (axe des y) par rapport à l'écart entre les valeurs cibles réelles et prédites (axe des x), ainsi que la distribution de l'erreur résiduelle. -En général, les résidus d'un modèle bien ajusté devraient être répartis aléatoirement, car un bon modèle explique la plupart des phénomènes d'un jeu de données, à l'exception de l'erreur aléatoire. +Les résidus d'un modèle bien ajusté devraient être répartis aléatoirement, car un bon modèle explique la plupart des phénomènes d'un jeu de données, à l'exception de l'erreur aléatoire. `wandb.sklearn.plot_residuals(model, X, y)` @@ -381,10 +389,10 @@ En général, les résidus d'un modèle bien ajusté devraient être répart * X (arr): Fonctionnalités de l'ensemble d'entraînement. * y (arr): Étiquettes de l'ensemble d'entraînement. - Si vous avez des questions, nous serons ravis d'y répondre dans notre [communauté Slack](https://wandb.me/slack). +Si vous avez des questions, posez-les dans la [communauté Slack](https://wandb.me/slack).
## Exemple
-* [Exécuter sur Colab](https://wandb.me/scikit-colab) : un notebook simple pour bien démarrer. \ No newline at end of file +[Exécuter sur Colab](https://wandb.me/scikit-colab) : un notebook simple pour bien démarrer. \ No newline at end of file diff --git a/fr/models/integrations/simpletransformers.mdx b/fr/models/integrations/simpletransformers.mdx index f04ca20c76..6313717287 100644 --- a/fr/models/integrations/simpletransformers.mdx +++ b/fr/models/integrations/simpletransformers.mdx @@ -3,6 +3,8 @@ description: Comment intégrer W&B à la bibliothèque Transformers de Hugging F title: Hugging Face Simple Transformers --- +Cette page montre comment intégrer Weights & Biases (W&B) à Simple Transformers afin de visualiser et de suivre l’entraînement des modèles Transformer. À la fin, vous saurez comment activer la journalisation W&B à partir d’un modèle Simple Transformers et où trouver des exemples pour les tâches NLP courantes. + Cette bibliothèque s’appuie sur la bibliothèque Transformers de Hugging Face. Simple Transformers vous permet d’entraîner et d’évaluer rapidement des modèles Transformer. Seules 3 lignes de code suffisent pour initialiser un modèle, l’entraîner et l’évaluer. Elle prend en charge la Classification de séquences, la Classification de tokens (NER), les Questions-réponses, le Fine-tuning de modèles de langage, l’entraînement de modèles de langage, la génération de langage, le modèle T5, les tâches Seq2Seq, la Classification multimodale et l’IA conversationnelle. Pour utiliser W&B afin de visualiser l’entraînement du modèle, définissez un nom de projet W&B dans l’attribut `wandb_project` du dictionnaire `args`. Cela consigne toutes les valeurs d’hyperparamètres, les pertes d’entraînement et les métriques d’évaluation dans le projet indiqué. @@ -17,7 +19,7 @@ Tout argument supplémentaire à transmettre à `wandb.init()` peut être passé ## Structure
-La bibliothèque est conçue avec une classe distincte pour chaque tâche de NLP. Les classes qui offrent des fonctionnalités similaires sont regroupées. +La section suivante explique comment Simple Transformers organise ses classes, afin que vous sachiez quel module importer pour une tâche donnée. La bibliothèque est conçue avec une classe distincte pour chaque tâche de NLP. Les classes qui offrent des fonctionnalités similaires sont regroupées. * `simpletransformers.classification` - Comprend tous les modèles de Classification. * `ClassificationModel` @@ -27,13 +29,13 @@ La bibliothèque est conçue avec une classe distincte pour chaque tâche de NLP * `simpletransformers.question_answering` - Comprend tous les modèles de Questions-réponses. * `QuestionAnsweringModel` -Voici quelques exemples simples +Les sections suivantes décrivent des exemples minimaux pour deux tâches courantes, en montrant comment activer la journalisation W&B via l’argument `wandb_project`. -
+
## Classification multi-étiquette
-```text +```python model = MultiLabelClassificationModel("distilbert","distilbert-base-uncased",num_labels=6, args={"reprocess_input_data": True, "overwrite_output_dir": True, "num_train_epochs":epochs,'learning_rate':learning_rate, 'wandb_project': "simpletransformers"}, @@ -45,12 +47,11 @@ Voici quelques exemples simples result, model_outputs, wrong_predictions = model.eval_model(eval_df) ``` -
## Questions-réponses
-```text +```python train_args = { 'learning_rate': wandb.config.learning_rate, 'num_train_epochs': 2, @@ -67,9 +68,13 @@ model = QuestionAnsweringModel('distilbert', 'distilbert-base-cased', args=train model.train_model(train_data) ``` -SimpleTransformers fournit des classes ainsi que des scripts d’entraînement pour toutes les tâches courantes de traitement du langage naturel. Voici la liste complète des arguments globaux pris en charge par la bibliothèque, ainsi que leurs valeurs par défaut. +
+ ## Arguments globaux +
-```text +SimpleTransformers fournit des classes ainsi que des scripts d’entraînement pour toutes les tâches courantes de traitement du langage naturel. Voici la liste complète des arguments globaux pris en charge par la bibliothèque, ainsi que leurs valeurs par défaut. Consultez cette liste si vous souhaitez personnaliser le comportement de l’entraînement au-delà des options spécifiques à W&B présentées précédemment. + +```python global_args = { "adam_epsilon": 1e-8, "best_model_dir": "outputs/best_model", @@ -124,6 +129,10 @@ global_args = { } ``` +
+ ## Ressources supplémentaires +
+ Consultez la documentation plus détaillée sur [simpletransformers sur GitHub](https://github.com/ThilinaRajapakse/simpletransformers). -Consultez [ce rapport W&B](https://app.wandb.ai/cayush/simpletransformers/reports/Using-simpleTransformer-on-common-NLP-applications---Vmlldzo4Njk2NA), qui présente l’entraînement de transformers sur quelques-uns des jeux de données de référence GLUE les plus populaires. [Essayez-le vous-même sur Colab](https://colab.research.google.com/drive/1oXROllqMqVvBFcPgTKJRboTq96uWuqSz?usp=sharing). +Voir [Using simpleTransformer on common NLP applications](https://app.wandb.ai/cayush/simpletransformers/reports/Using-simpleTransformer-on-common-NLP-applications---Vmlldzo4Njk2NA), un W&B Report qui présente l’entraînement de transformers sur quelques-uns des jeux de données de référence GLUE les plus populaires. [Essayez-le vous-même sur Colab](https://colab.research.google.com/drive/1oXROllqMqVvBFcPgTKJRboTq96uWuqSz?usp=sharing). \ No newline at end of file diff --git a/fr/models/integrations/skorch.mdx b/fr/models/integrations/skorch.mdx index 5e2cd8013c..d3570e4f88 100644 --- a/fr/models/integrations/skorch.mdx +++ b/fr/models/integrations/skorch.mdx @@ -3,28 +3,30 @@ description: "Intégrez W&B à Skorch pour journaliser les métriques et les hyp title: Skorch --- -Vous pouvez utiliser W&B avec Skorch pour journaliser automatiquement le modèle le plus performant, ainsi que toutes les métriques de performance du modèle, sa topologie et les ressources de calcul après chaque époque. Chaque fichier enregistré dans `wandb_run.dir` est automatiquement journalisé dans W&B. +Cette page vous montre comment utiliser W&B avec [Skorch](https://skorch.readthedocs.io/) afin de vous permettre de suivre l'entraînement des modèles Skorch sans écrire de code de journalisation personnalisé. Lorsque vous intégrez les deux, W&B journalise automatiquement le modèle le plus performant, ainsi que toutes les métriques de performance du modèle, sa topologie et les ressources de calcul après chaque époque. W&B journalise automatiquement chaque fichier que vous enregistrez dans `wandb_run.dir`. -Voir [un exemple de run](https://app.wandb.ai/borisd13/skorch/runs/s20or4ct?workspace=user-borisd13). +Pour plus d'informations, voir cet [exemple de run](https://app.wandb.ai/borisd13/skorch/runs/s20or4ct?workspace=user-borisd13).
## Paramètres
-| Paramètre | Type | Description | -| :------------- | :-------------------------------- | :------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | -| `wandb_run` | `wandb.wandb_run`. Run | run wandb utilisé pour journaliser les données. | -| `save_model` | bool (default=True) | Indique s'il faut enregistrer un checkpoint du meilleur modèle et le téléverser vers votre Run sur W&B. | -| `keys_ignored` | str or list of str (default=None) | Clé ou liste de clés qui ne doivent pas être journalisées dans TensorBoard. Notez qu'en plus des clés fournies par l'utilisateur, les clés commençant par `event_` ou se terminant par `_best` sont ignorées par défaut. | +Le tableau suivant répertorie les paramètres que le callback `WandbLogger` accepte. + +| Paramètre | Type | Description | +| :------------- | :--------------------------------------- | :------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------ | +| `wandb_run` | `wandb.wandb_run`. Run | Le run W&B utilisé pour journaliser les données. | +| `save_model` | `bool` (default=`True`) | Indique s’il faut enregistrer un point de contrôle du meilleur modèle et le téléverser dans votre run sur W&B. | +| `keys_ignored` | `str` ou liste de `str` (default=`None`) | Clé ou liste de clés à ne pas journaliser dans TensorBoard. En plus des clés que vous fournissez, W&B ignore par défaut les clés qui commencent par `event_` ou se terminent par `_best`. |
## Exemples de code
-Nous avons créé quelques exemples pour vous montrer comment l’intégration fonctionne : +Les exemples suivants montrent l’utilisation de bout en bout de `WandbLogger` avec Skorch : -* [Colab](https://colab.research.google.com/drive/1Bo8SqN1wNPMKv5Bn9NjwGecBxzFlaNZn?usp=sharing): une démo simple pour essayer l’intégration -* [Un guide étape par étape](https://app.wandb.ai/cayush/uncategorized/reports/Automate-Kaggle-model-training-with-Skorch-and-W%26B--Vmlldzo4NTQ1NQ) : pour suivre les performances de votre modèle Skorch +* [Colab](https://colab.research.google.com/drive/1Bo8SqN1wNPMKv5Bn9NjwGecBxzFlaNZn?usp=sharing) : une démo simple pour essayer l’intégration. +* [Guide étape par étape](https://app.wandb.ai/cayush/uncategorized/reports/Automate-Kaggle-model-training-with-Skorch-and-W%26B--Vmlldzo4NTQ1NQ) : un guide pas à pas pour suivre les performances de votre modèle Skorch. ```bash pip install wandb @@ -34,7 +36,7 @@ pip install wandb import wandb from skorch.callbacks import WandbLogger -# Créer un Run wandb +# Créer un run wandb wandb_run = wandb.init() # Journaliser les hyperparamètres (facultatif) @@ -48,13 +50,15 @@ net.fit(X, y) ## Référence des méthodes
-| Méthode | Description | -| :---------------------------------------------------- | :--------------------------------------------------------------------------------------------------------- | -| `initialize`() | (Ré-)initialise l’état initial du callback. | -| `on_batch_begin`(net[, X, y, training]) | Appelée au début de chaque lot. | -| `on_batch_end`(net[, X, y, training]) | Appelée à la fin de chaque lot. | -| `on_epoch_begin`(net[, dataset_train, …]) | Appelée au début de chaque époque. | -| `on_epoch_end`(net, **kwargs) | Journalise les valeurs de la dernière étape de l’historique et enregistre le meilleur modèle | -| `on_grad_computed`(net, named_parameters[, X, …]) | Appelée une fois par lot, après le calcul des gradients mais avant l’exécution d’une étape de mise à jour. | -| `on_train_begin`(net, **kwargs) | Journalise la topologie du modèle et ajoute un hook pour les gradients | -| `on_train_end`(net[, X, y]) | Appelée à la fin de l’entraînement. | \ No newline at end of file +Le tableau suivant répertorie les méthodes de callback que `WandbLogger` fournit et le moment où Skorch invoque chacune d’elles. + +| Méthode | Description | +| :------------------------------------------------------ | :--------------------------------------------------------------------------------------------------------- | +| `initialize`() | (Ré-)initialise l’état initial du callback. | +| `on_batch_begin`(net[, X, y, training]) | Appelée au début de chaque lot. | +| `on_batch_end`(net[, X, y, training]) | Appelée à la fin de chaque lot. | +| `on_epoch_begin`(net[, dataset_train, ...]) | Appelée au début de chaque époque. | +| `on_epoch_end`(net, **kwargs) | Journalise les valeurs de la dernière étape de l’historique et enregistre le meilleur modèle. | +| `on_grad_computed`(net, named_parameters[, X, ...]) | Appelée une fois par lot, après le calcul des gradients mais avant l’exécution d’une étape de mise à jour. | +| `on_train_begin`(net, **kwargs) | Journalise la topologie du modèle et ajoute un hook pour les gradients. | +| `on_train_end`(net[, X, y]) | Appelée à la fin de l’entraînement. | \ No newline at end of file diff --git a/fr/models/integrations/spacy.mdx b/fr/models/integrations/spacy.mdx index b9576c1383..1ac7834d0d 100644 --- a/fr/models/integrations/spacy.mdx +++ b/fr/models/integrations/spacy.mdx @@ -5,7 +5,9 @@ description: "Intégrez W&B à spaCy v3 pour suivre les métriques d'entraîneme import ApiKeyCreateStreamlined from "/snippets/fr/_includes/api-key-create-streamlined.mdx"; -[spaCy](https://spacy.io) est une bibliothèque de TAL populaire « de niveau industriel » : des modèles rapides et précis, sans complexité inutile. Depuis spaCy v3, W&B peut désormais être utilisé avec [`spacy train`](https://spacy.io/api/cli#train) pour suivre les métriques d'entraînement de votre modèle spaCy, ainsi que pour enregistrer et versionner vos modèles et jeux de données. Il suffit pour cela d'ajouter quelques lignes à votre configuration. +[spaCy](https://spacy.io) est une bibliothèque de TAL qui fournit des modèles rapides et précis. Depuis spaCy v3, vous pouvez utiliser W&B avec [`spacy train`](https://spacy.io/api/cli#train) pour suivre les métriques d'entraînement de votre modèle spaCy, ainsi que pour enregistrer et versionner vos modèles et jeux de données. Il suffit pour cela d'ajouter quelques lignes à votre configuration. + +Si vous utilisez spaCy, cette page explique comment utiliser W&B pour surveiller les runs d'entraînement, comparer les expériences et versionner les modèles et les jeux de données produits par `spacy train`.
## Inscrivez-vous et créez une clé API @@ -26,7 +28,7 @@ Pour installer la bibliothèque `wandb` localement et vous connecter : - 1. Définissez la variable d'environnement [`WANDB_API_KEY`](/fr/models/track/environment-variables/) avec votre clé API. + 1. Définissez la variable d'environnement [`WANDB_API_KEY`](/fr/models/track/environment-variables/) avec votre clé API. Remplacez les valeurs entre `<>` par les vôtres : ```bash export WANDB_API_KEY= @@ -66,10 +68,10 @@ Pour installer la bibliothèque `wandb` localement et vous connecter : ## Ajoutez `WandbLogger` à votre fichier de configuration spaCy
-Les fichiers de configuration spaCy servent à définir tous les aspects de l’entraînement, pas uniquement la journalisation : allocation du GPU, choix de l’optimiseur, chemins des jeux de données, et bien plus encore. Au minimum, dans `[training.logger]`, vous devez renseigner la clé `@loggers` avec la valeur `"spacy.WandbLogger.v3"`, ainsi qu’un `project_name`. +Les fichiers de configuration spaCy définissent tous les aspects de l’entraînement, pas seulement la journalisation (attribution du GPU, choix de l’optimiseur, chemins d’accès au jeu de données, etc.). Au minimum, sous `[training.logger]`, vous devez fournir la clé `@loggers` avec la valeur `"spacy.WandbLogger.v3"`, ainsi qu’un `project_name`. - Pour en savoir plus sur le fonctionnement des fichiers de configuration d’entraînement de spaCy et sur les autres options que vous pouvez fournir pour personnaliser l’entraînement, consultez la [documentation de spaCy](https://spacy.io/usage/training). + Pour en savoir plus sur le fonctionnement des fichiers de configuration d’entraînement de spaCy et sur les autres options que vous pouvez spécifier pour personnaliser l’entraînement, voir la [documentation de spaCy](https://spacy.io/usage/training). ```python @@ -81,24 +83,26 @@ log_dataset_dir = "./corpus" model_log_interval = 1000 ``` -| Nom | Description | -| ---------------------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | -| `project_name` | `str`. Le nom du projet W&B. Le projet sera créé automatiquement s’il n’existe pas encore. | -| `remove_config_values` | `List[str]` . Une liste de valeurs à exclure de la configuration avant son envoi vers W&B. `[]` par défaut. | -| `model_log_interval` | `Optional int`. `None` par défaut. S’il est défini, active la [gestion des versions des modèles](/fr/models/registry/) avec [Artifacts](/fr/models/artifacts/). Indiquez le nombre d’étapes à attendre entre chaque enregistrement de point de contrôle du modèle. `None` par défaut. | -| `log_dataset_dir` | `Optional str`. Si un chemin est fourni, le jeu de données sera téléversé en tant qu’Artifact au début de l’entraînement. `None` par défaut. | -| `entity` | `Optional str` . Si fourni, le run sera créé dans l’entité spécifiée | -| `run_name` | `Optional str` . Si spécifié, le run sera créé avec le nom indiqué. | +Le tableau suivant décrit les options de configuration de `WandbLogger` : + +| Nom | Description | +| ---------------------- | -------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | +| `project_name` | `str`. Le nom du projet W&B. W&B crée automatiquement le projet s'il n'existe pas encore. | +| `remove_config_values` | `List[str]` . Une liste de valeurs à exclure de la configuration avant son téléversement vers W&B. `[]` par défaut. | +| `model_log_interval` | `Optional int`. `None` par défaut. Si cette valeur est définie, elle active la [gestion des versions des modèles](/fr/models/registry/) avec des [artefacts](/fr/models/artifacts/). Indiquez le nombre d'étapes à attendre entre deux journalisations des points de contrôle du modèle. | +| `log_dataset_dir` | `Optional str`. Si vous fournissez un chemin, W&B téléverse le jeu de données en tant qu'artefact au début de l'entraînement. `None` par défaut. | +| `entity` | `Optional str` . Si elle est fournie, W&B crée le run dans l'entité spécifiée. | +| `run_name` | `Optional str` . Si elle est spécifiée, W&B crée le run avec le nom indiqué. |
## Lancer l'entraînement
-Une fois que vous avez ajouté `WandbLogger` à votre configuration d'entraînement spaCy, vous pouvez exécuter `spacy train` comme d'habitude. +Une fois `WandbLogger` ajouté à votre configuration d'entraînement spaCy, vous pouvez exécuter `spacy train` comme d'habitude, et W&B capture automatiquement le run. - ```python + ```bash python -m spacy train \ config.cfg \ --output ./output \ @@ -128,4 +132,4 @@ Une fois que vous avez ajouté `WandbLogger` à votre configuration d'entra -Au démarrage de l'entraînement, un lien vers la [page W&B](/fr/models/runs/) de votre run d'entraînement s'affiche. Il vous redirige vers le [tableau de bord](/fr/models/track/workspaces/) de suivi des expériences de ce run dans l'interface web de W&B. \ No newline at end of file +Au démarrage de l'entraînement, spaCy affiche un lien vers la [page W&B](/fr/models/runs/) de votre run d'entraînement. Il vous redirige vers le [tableau de bord](/fr/models/track/workspaces/) de suivi des expériences de ce run dans l'interface web de W&B. \ No newline at end of file diff --git a/fr/models/integrations/stable-baselines-3.mdx b/fr/models/integrations/stable-baselines-3.mdx index cd3655d8ce..e808355d9f 100644 --- a/fr/models/integrations/stable-baselines-3.mdx +++ b/fr/models/integrations/stable-baselines-3.mdx @@ -17,6 +17,8 @@ Consultez un [exemple de run d'entraînement SB3](https://wandb.ai/wandb/sb3 ## Journalisez vos expériences SB3
+Pour journaliser l’entraînement SB3 dans W&B, passez `WandbCallback` à la méthode `learn` de votre modèle : + ```python from wandb.integration.sb3 import WandbCallback @@ -27,23 +29,24 @@ model.learn(..., callback=WandbCallback()) Entraînement de Stable Baselines 3 avec W&B -
- ## Arguments de WandbCallback + ## Arguments de `WandbCallback`
-| Argument | Utilisation | -| :------------------- | :---------------------------------------------------------------------------------------------------------------------------- | -| `verbose` | Niveau de verbosité de la sortie de sb3 | -| `model_save_path` | Chemin vers le dossier où le modèle sera enregistré. La valeur par défaut est `None`, donc le modèle n'est pas enregistré | -| `model_save_freq` | Fréquence d'enregistrement du modèle | -| `gradient_save_freq` | Fréquence d'enregistrement des gradients. La valeur par défaut est 0, donc les gradients ne sont pas enregistrés | +Le tableau suivant décrit les arguments que vous pouvez passer à `WandbCallback` : + +| Argument | Utilisation | +| :------------------- | :--------------------------------------------------------------------------------------------------------------------------------- | +| `verbose` | Niveau de verbosité de la sortie SB3. | +| `model_save_path` | Chemin du dossier dans lequel le modèle est enregistré. Par défaut, la valeur est `None`, donc le modèle n'est pas journalisé. | +| `model_save_freq` | Fréquence d'enregistrement du modèle. | +| `gradient_save_freq` | Fréquence de journalisation des gradients. Par défaut, la valeur est `0`, donc les gradients ne sont pas journalisés. |
## Exemple de base
-L’intégration W&B SB3 utilise les journaux générés par TensorBoard pour journaliser vos métriques +L’intégration W&B SB3 utilise les journaux générés par TensorBoard pour journaliser vos métriques. ```python import gym @@ -62,15 +65,15 @@ config = { run = wandb.init( project="sb3", config=config, - sync_tensorboard=True, # téléverse automatiquement les métriques TensorBoard de sb3 - monitor_gym=True, # téléverse automatiquement les vidéos des agents pendant la partie + sync_tensorboard=True, # téléversement automatique des métriques TensorBoard de sb3 + monitor_gym=True, # téléversement automatique des vidéos des agents jouant au jeu save_code=True, # facultatif ) def make_env(): env = gym.make(config["env_name"]) - env = Monitor(env) # enregistre des statistiques comme les retours cumulés + env = Monitor(env) # enregistre des statistiques telles que les retours return env @@ -91,4 +94,4 @@ model.learn( ), ) run.finish() -``` +``` \ No newline at end of file diff --git a/fr/models/integrations/tensorboard.mdx b/fr/models/integrations/tensorboard.mdx index 089be0577f..d95a31af67 100644 --- a/fr/models/integrations/tensorboard.mdx +++ b/fr/models/integrations/tensorboard.mdx @@ -11,7 +11,7 @@ import { ColabLink } from '/snippets/fr/_includes/colab-link.mdx'; W&B prend en charge TensorBoard intégré pour W&B Cloud mutualisé. -Téléversez vos journaux TensorBoard dans le cloud, partagez rapidement vos résultats avec vos collègues et camarades de classe et conservez votre analyse au même endroit. +Cette page explique comment synchroniser les journaux TensorBoard avec W&B afin que vous puissiez téléverser vos journaux TensorBoard dans le cloud, partager vos résultats avec vos collègues et camarades de classe et conserver votre analyse au même endroit. Utilisez cette intégration si vous journalisez déjà dans TensorBoard et souhaitez bénéficier d’une visualisation hébergée dans le cloud, du partage et d’une comparaison côte à côte avec les métriques système de W&B. Code d’intégration TensorBoard @@ -21,6 +21,8 @@ Téléversez vos journaux TensorBoard dans le cloud, partagez rapidement vos ré ## Premiers pas
+Pour activer la synchronisation de TensorBoard, définissez `sync_tensorboard=True` lorsque vous initialisez un run W&B. W&B téléverse automatiquement tous les événements TensorBoard émis par votre code d’entraînement. + ```python import wandb @@ -33,19 +35,23 @@ with wandb.init(project="my-project", sync_tensorboard=True) as run: Consultez un [exemple de run avec intégration TensorBoard](https://wandb.ai/rymc/simple-tensorboard-example/runs/oab614zf/tensorboard). -Une fois votre run terminé, vous pouvez accéder à vos fichiers d’événements TensorBoard dans W&B et visualiser vos métriques dans les graphiques natifs de W&B, avec d’autres informations utiles comme l’utilisation du CPU ou du GPU du système, l’état de `git`, la commande de terminal utilisée pour le run, et plus encore. +Une fois votre run terminé, vous pouvez accéder à vos fichiers d’événements TensorBoard dans W&B et visualiser vos métriques dans les graphiques natifs de W&B. W&B capture également des informations supplémentaires telles que l’utilisation du CPU ou du GPU du système, l’état de `git` et la commande de terminal utilisée pour le run. -W&B prend en charge TensorBoard avec toutes les versions de TensorFlow. W&B prend également en charge TensorBoard 1.14 et les versions ultérieures avec PyTorch, ainsi que TensorBoardX. + + W&B prend en charge TensorBoard avec toutes les versions de TensorFlow. W&B prend également en charge TensorBoard 1.14 et les versions ultérieures avec PyTorch, ainsi que TensorBoardX. +
## Questions fréquentes
+Les sections suivantes répondent aux questions les plus courantes sur la personnalisation de l’intégration TensorBoard, notamment la journalisation de métriques supplémentaires, la configuration du patch, la synchronisation de runs historiques et l’utilisation d’environnements notebook. +
### Comment puis-je consigner dans W&B des métriques qui ne sont pas enregistrées dans TensorBoard ?
-Si vous devez consigner des métriques personnalisées supplémentaires qui ne sont pas enregistrées dans TensorBoard, vous pouvez appeler `wandb.Run.log()` dans votre code : `run.log({"custom": 0.8})` +Si vous devez consigner des métriques personnalisées supplémentaires qui ne sont pas enregistrées dans TensorBoard, vous pouvez appeler `wandb.Run.log()` dans votre code : `run.log({"custom": 0.8})`. Le paramètre `step` dans `run.log()` est désactivé lors de la synchronisation avec TensorBoard. Si vous souhaitez définir un nombre d’étapes différent, vous pouvez consigner les métriques avec une métrique d’étape, comme suit : @@ -55,7 +61,7 @@ Le paramètre `step` dans `run.log()` est désactivé lors de la synchronisation ### Comment puis-je configurer TensorBoard lorsque je l’utilise avec `wandb` ?
-Si vous voulez mieux contrôler la manière dont TensorBoard est patché, vous pouvez appeler `wandb.tensorboard.patch()` au lieu de passer `sync_tensorboard=True` à `wandb.init()`. +Si vous voulez mieux contrôler la manière dont W&B applique un patch à TensorBoard, appelez `wandb.tensorboard.patch()` au lieu de passer `sync_tensorboard=True` à `wandb.init()`. ```python import wandb @@ -67,9 +73,9 @@ run = wandb.init() run.finish() ``` -Vous pouvez passer `tensorboard_x=False` à cette méthode pour vous assurer que le TensorBoard standard est patché. Si vous utilisez TensorBoard > 1.14 avec PyTorch, vous pouvez passer `pytorch=True` pour vous assurer qu'il est patché. Ces deux options ont des valeurs par défaut intelligentes selon les versions de ces bibliothèques qui ont été importées. +Pour patcher le TensorBoard standard, passez `tensorboard_x=False` à cette méthode. Si vous utilisez TensorBoard version ultérieure à 1.14 avec PyTorch, passez `pytorch=True` pour le patcher. Ces deux options ont des valeurs par défaut intelligentes selon les versions de ces bibliothèques qui ont été importées. -Par défaut, nous synchronisons également les fichiers `tfevents` ainsi que tous les fichiers `.pbtxt`. Cela nous permet de lancer une instance TensorBoard pour votre compte. Vous verrez un [onglet TensorBoard](https://www.wandb.com/articles/hosted-tensorboard) sur la page du run. Ce comportement peut être désactivé en passant `save=False` à `wandb.tensorboard.patch` +Par défaut, W&B synchronise également les fichiers `tfevents` ainsi que tous les fichiers `.pbtxt`. Cela permet à W&B de lancer une instance TensorBoard pour votre compte. Vous verrez un [onglet TensorBoard](https://www.wandb.com/articles/hosted-tensorboard) sur la page du run. Pour désactiver ce comportement, passez `save=False` à `wandb.tensorboard.patch`. ```python import wandb @@ -82,7 +88,7 @@ run.finish() ``` - Vous devez appeler soit `wandb.init()`, soit `wandb.tensorboard.patch()` **avant** d'appeler `tf.summary.create_file_writer()` ou d'instancier un `SummaryWriter` via `torch.utils.tensorboard`. + Vous devez appeler soit `wandb.init()`, soit `wandb.tensorboard.patch()` avant d'appeler `tf.summary.create_file_writer()` ou d'instancier un `SummaryWriter` à partir de `torch.utils.tensorboard`.
@@ -95,7 +101,7 @@ Si vous avez des fichiers `tfevents` déjà stockés localement et que vous souh ### Comment puis-je utiliser Google Colab ou Jupyter avec TensorBoard ?
-Si vous exécutez votre code dans un notebook Jupyter ou Colab, assurez-vous d’appeler `wandb.Run.finish()` à la fin de votre entraînement. Cela mettra fin au run wandb et importera les journaux TensorBoard dans W&B pour que vous puissiez les visualiser. Cela n’est pas nécessaire lorsque vous exécutez un script `.py`, car wandb se termine automatiquement à la fin du script. +Si vous exécutez votre code dans un notebook Jupyter ou Colab, assurez-vous d’appeler `wandb.Run.finish()` à la fin de votre entraînement. Cela met fin au run `wandb` et téléverse les journaux TensorBoard dans W&B pour qu’ils puissent être visualisés. Cela n’est pas nécessaire lorsque vous exécutez un script `.py`, car `wandb` se termine automatiquement à la fin du script. Pour exécuter des commandes shell dans un environnement de notebook, vous devez les faire précéder d’un `!`, comme dans `!wandb sync directoryname`. @@ -115,7 +121,7 @@ with wandb.init(project="my-project", sync_tensorboard=True) as run: ### Puis-je synchroniser des fichiers tfevents stockés dans le cloud ?
-`wandb` 0.20.0 et les versions ultérieures prennent en charge la synchronisation des fichiers `tfevents` stockés dans S3, GCS ou Azure. `wandb` utilise les identifiants par défaut de chaque fournisseur cloud, correspondant aux commandes du tableau suivant : +`wandb` 0.20.0 et les versions ultérieures prennent en charge la synchronisation des fichiers `tfevents` stockés dans S3, GCS ou Azure. `wandb` utilise les identifiants par défaut de chaque fournisseur cloud. Le tableau suivant répertorie la commande permettant de configurer les identifiants ainsi que le format attendu du répertoire des journaux pour chaque fournisseur : | Fournisseur cloud | Identifiants | Format du répertoire des journaux | | ----------------- | --------------------------------------- | ------------------------------------- | diff --git a/fr/models/integrations/tensorflow.mdx b/fr/models/integrations/tensorflow.mdx index a694b110b5..2ac7b0f620 100644 --- a/fr/models/integrations/tensorflow.mdx +++ b/fr/models/integrations/tensorflow.mdx @@ -7,25 +7,28 @@ import { ColabLink } from '/snippets/fr/_includes/colab-link.mdx'; +Cette page explique comment intégrer W&B à TensorFlow pour suivre les expériences, consigner des métriques et synchroniser les journaux TensorBoard. Suivez ces approches pour capturer les données d’entraînement des modèles TensorFlow, personnaliser ce que vous consignez à l’aide de hooks d’estimateur ou d’une journalisation manuelle, et réutiliser vos flux de travail TensorBoard existants avec le tableau de bord centralisé de W&B. Utilisez cette intégration si vous souhaitez un suivi des expériences plus riche que celui fourni par TensorBoard seul. +
## Pour commencer
-Si vous utilisez déjà TensorBoard, son intégration avec wandb est simple. +Si vous utilisez déjà TensorBoard, vous pouvez l’intégrer à W&B. Importez les deux bibliothèques afin de pouvoir utiliser les API W&B et TensorFlow dans votre script. ```python import tensorflow as tf import wandb ``` -
- ## Journaliser des métriques personnalisées + ## Consigner des métriques personnalisées
-Si vous devez journaliser d’autres métriques personnalisées qui ne sont pas envoyées à TensorBoard, vous pouvez appeler `run.log()` dans votre code `run.log({"custom": 0.8}) ` +Cette section explique comment consigner des métriques que TensorBoard ne capture pas déjà, afin que vous puissiez suivre des valeurs supplémentaires en plus de vos résumés TensorBoard standard. + +Si vous devez consigner d’autres métriques personnalisées que TensorBoard ne journalise pas, vous pouvez appeler `run.log()` dans votre code, par exemple `run.log({"custom": 0.8})`. -Le paramétrage de l’argument `step` dans `run.log()` est désactivé lors de la synchronisation avec TensorBoard. Si vous souhaitez utiliser un nombre d’étapes différent, vous pouvez journaliser les métriques avec une métrique d’étape, comme suit : +W&B désactive l’argument `step` dans `run.log()` lors de la synchronisation avec TensorBoard. Pour définir un nombre d’étapes différent, consignez les métriques avec une métrique d’étape, comme suit : ```python with wandb.init(config=tf.flags.FLAGS, sync_tensorboard=True) as run: @@ -36,7 +39,9 @@ with wandb.init(config=tf.flags.FLAGS, sync_tensorboard=True) as run: ## Hook pour les estimateurs TensorFlow
-Si vous souhaitez mieux contrôler ce qui est journalisé, wandb propose également un hook pour les estimateurs TensorFlow. Ce hook journalise toutes les valeurs `tf.summary` du graphe. +Cette section décrit le hook W&B pour les estimateurs TensorFlow, qui vous permet de contrôler finement ce que W&B capture pendant l’entraînement de l’estimateur. + +Si vous souhaitez mieux contrôler ce qui est journalisé, W&B propose également un hook pour les estimateurs TensorFlow. Ce hook journalise toutes les valeurs `tf.summary` du graphe. ```python import tensorflow as tf @@ -52,7 +57,9 @@ run.finish() ## Journaliser manuellement
-Le moyen le plus simple de journaliser des métriques dans TensorFlow consiste à utiliser `tf.summary` avec le logger de TensorFlow : +Si vous n’utilisez pas d’estimateurs ou si vous souhaitez consigner explicitement des synthèses spécifiques, cette section montre comment envoyer directement des valeurs `tf.summary` à W&B. + +Une façon de consigner des métriques dans TensorFlow consiste à utiliser `tf.summary` avec le logger de TensorFlow : ```python import wandb @@ -62,7 +69,7 @@ with tf.Session() as sess: wandb.tensorflow.log(tf.summary.merge_all()) ``` -Avec TensorFlow 2, la manière recommandée d’entraîner un modèle avec une boucle personnalisée est d’utiliser `tf.GradientTape`. Pour en savoir plus, consultez le [guide pas à pas TensorFlow sur l’entraînement personnalisé](https://www.tensorflow.org/tutorials/customization/custom_training_walkthrough). Si vous souhaitez intégrer `wandb` pour journaliser des métriques dans vos boucles d’entraînement TensorFlow personnalisées, vous pouvez vous appuyer sur cet extrait : +Avec TensorFlow 2, la manière recommandée d’entraîner un modèle avec une boucle personnalisée est d’utiliser `tf.GradientTape`. Pour plus d'informations, voir le [guide pas à pas TensorFlow sur l’entraînement personnalisé](https://www.tensorflow.org/tutorials/customization/custom_training_walkthrough). Pour intégrer W&B afin de consigner des métriques dans vos boucles d’entraînement TensorFlow personnalisées, suivez cet extrait : ```python with tf.GradientTape() as tape: @@ -71,7 +78,7 @@ Avec TensorFlow 2, la manière recommandée d’entraîner un modèle avec une b # Calculer la perte loss = loss_func(labels, predictions) - # Journaliser vos métriques + # Consigner vos métriques run.log({"loss": loss.numpy()}) # Obtenir les gradients gradients = tape.gradient(loss, model.trainable_variables) @@ -81,28 +88,30 @@ Avec TensorFlow 2, la manière recommandée d’entraîner un modèle avec une b Un [exemple complet pour personnaliser les boucles d'entraînement dans TensorFlow 2](https://www.wandb.com/articles/wandb-customizing-training-loops-in-tensorflow-2) est disponible. -
- ## En quoi W&B se distingue-t-il de TensorBoard ? +
+ ## Différences entre W&B et TensorBoard
-Lorsque les cofondateurs ont commencé à travailler sur W&B, ils ont voulu créer un outil pour les utilisateurs de TensorBoard frustrés chez OpenAI. Voici quelques points sur lesquels nous nous sommes attachés à progresser : +Si vous vous demandez s’il faut adopter W&B en complément de TensorBoard ou à la place, cette section met en évidence les principales différences. + +W&B a été conçu pour remédier aux limites couramment rencontrées par les utilisateurs de TensorBoard. Voici les principaux points qui distinguent W&B : -1. **Reproduire les modèles** : W&B est particulièrement utile pour expérimenter, explorer et reproduire des modèles plus tard. Nous capturons non seulement les métriques, mais aussi les hyperparamètres et la version du code. Nous pouvons également enregistrer l’état de votre contrôle de version ainsi que les points de contrôle du modèle, afin que votre projet soit reproductible. -2. **Organisation automatique** : Que vous repreniez un projet d’un collaborateur, reveniez de vacances ou ressortiez un ancien projet, W&B permet de voir facilement tous les modèles déjà testés, afin que personne ne perde des heures, des cycles GPU ou du carbone à relancer des expériences. -3. **Intégration rapide et flexible** : Ajoutez W&B à votre projet en 5 minutes. Installez notre package Python gratuit et open source, ajoutez quelques lignes à votre code, et chaque fois que vous exécuterez votre modèle, vos métriques et vos enregistrements seront automatiquement enregistrés. -4. **Tableau de bord persistant et centralisé** : Peu importe où vous entraînez vos modèles, que ce soit sur votre machine locale, sur un cluster de laboratoire partagé ou sur des instances spot dans le cloud, vos résultats sont centralisés dans le même tableau de bord. Vous n’avez pas besoin de passer du temps à copier et à organiser des fichiers TensorBoard provenant de différentes machines. -5. **Tableaux puissants** : Recherchez, filtrez, triez et regroupez les résultats de différents modèles. Il est facile d’examiner des milliers de versions de modèles et de trouver les plus performants pour différentes tâches. TensorBoard n’est pas conçu pour fonctionner efficacement sur de grands projets. -6. **Outils de collaboration** : Utilisez W&B pour organiser des projets complexes de machine learning. Il est facile de partager un lien vers W&B, et vous pouvez utiliser des Teams privés pour que tout le monde envoie ses résultats vers un projet partagé. Nous prenons également en charge la collaboration via les Reports — ajoutez des visualisations interactives et décrivez votre travail en markdown. C’est un excellent moyen de tenir un journal de travail, de partager vos conclusions avec votre responsable ou de présenter vos résultats à votre laboratoire ou à votre équipe. +* **Reproduire les modèles** : W&B prend en charge l’expérimentation, l’exploration et la reproduction ultérieure des modèles. W&B capture les métriques, les hyperparamètres et la version du code, et peut enregistrer l’état de votre gestion de versions ainsi que les points de contrôle du modèle afin de rendre votre projet reproductible. +* **Organisation automatique** : Lorsque vous reprenez un projet d’un collaborateur, y revenez après une période d’absence ou revisitez un ancien projet, W&B vous permet de voir les modèles que vous avez déjà essayés afin de ne pas relancer inutilement des expériences. +* **Intégration flexible** : Ajoutez W&B à votre projet en installant le package Python open source et en ajoutant quelques lignes à votre code. Chaque run produit des métriques et des enregistrements. +* **Tableau de bord centralisé et persistant** : Que vous entraîniez vos modèles sur votre machine locale, sur un cluster de laboratoire partagé ou sur des instances spot dans le cloud, W&B envoie vos résultats vers un même tableau de bord centralisé. Vous n’avez pas besoin de copier et d’organiser des fichiers TensorBoard provenant de différentes machines. +* **Tableaux** : Recherchez, filtrez, triez et regroupez les résultats de différents modèles. Vous pouvez examiner les versions des modèles et trouver les plus performants pour différentes tâches. +* **Outils de collaboration** : Utilisez W&B pour organiser vos projets de machine learning. Partagez un lien vers W&B ou utilisez des Teams privées pour envoyer des résultats vers un projet partagé. Reports prend en charge la collaboration grâce à des visualisations interactives et à des descriptions en Markdown, que vous pouvez utiliser pour tenir un journal de travail, partager vos conclusions avec votre responsable ou les présenter à votre laboratoire ou à votre équipe. -Créez un [compte gratuit](https://wandb.ai) +Pour essayer W&B, [créez un compte gratuit](https://wandb.ai).
## Exemples
-Nous avons créé quelques exemples pour vous montrer comment fonctionne l’intégration : +Pour voir ces schémas d’intégration appliqués à des projets complets, explorez les exemples suivants : -* [Example on Github](https://github.com/wandb/examples/blob/master/examples/tensorflow/tf-estimator-mnist/mnist.py) : exemple MNIST utilisant les estimateurs TensorFlow -* [Example on Github](https://github.com/wandb/examples/blob/master/examples/tensorflow/tf-cnn-fashion/train.py) : exemple Fashion MNIST utilisant TensorFlow brut -* [Tableau de bord Wandb](https://app.wandb.ai/l2k2/examples-tf-estimator-mnist/runs/p0ifowcb) : voir le résultat sur W&B -* Personnaliser les boucles d’entraînement dans TensorFlow 2 - [Article](https://www.wandb.com/articles/wandb-customizing-training-loops-in-tensorflow-2) | [Tableau de bord](https://app.wandb.ai/sayakpaul/custom_training_loops_tf) \ No newline at end of file +* [Exemple MNIST avec estimateurs TensorFlow](https://github.com/wandb/examples/blob/master/examples/tensorflow/tf-estimator-mnist/mnist.py). +* [Exemple Fashion MNIST avec TensorFlow pur](https://github.com/wandb/examples/blob/master/examples/tensorflow/tf-cnn-fashion/train.py). +* [Tableau de bord W&B pour l’exemple MNIST](https://app.wandb.ai/l2k2/examples-tf-estimator-mnist/runs/p0ifowcb). +* Personnalisation des boucles d’entraînement dans TensorFlow 2 : [article](https://www.wandb.com/articles/wandb-customizing-training-loops-in-tensorflow-2) et [tableau de bord](https://app.wandb.ai/sayakpaul/custom_training_loops_tf). \ No newline at end of file diff --git a/fr/models/integrations/torchtune.mdx b/fr/models/integrations/torchtune.mdx index 520fd2358d..81aa0c8bb7 100644 --- a/fr/models/integrations/torchtune.mdx +++ b/fr/models/integrations/torchtune.mdx @@ -7,18 +7,22 @@ import { ColabLink } from '/snippets/fr/_includes/colab-link.mdx'; -[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. +[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 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. + +Ce guide vous montre comment activer la journalisation W&B dans les recettes torchtune, configurer le logger de métriques `WandBLogger`, comprendre quelles métriques torchtune suit par défaut et enregistrer les points de contrôle du modèle dans W&B Artifacts. - tableau de bord d’entraînement de TorchTune + 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](https://wandb.ai/capecape/torchtune-mistral/reports/torchtune-The-new-PyTorch-LLM-fine-tuning-library---Vmlldzo3NTUwNjM0). -
- ## La journalisation W&B à portée de main +
+ ## Activez la journalisation W&B
+Vous pouvez activer la journalisation W&B de deux façons : redéfinir les arguments au lancement depuis la ligne de commande, ou modifier le fichier de configuration de la recette. Choisissez l’option qui convient le mieux à votre flux de travail. + Redéfinissez les arguments de ligne de commande au lancement : @@ -79,11 +83,11 @@ Vous pouvez aussi transmettre n’importe quels autres `kwargs`, comme vous le f -
- ## Qu’est-ce qui est enregistré ? +
+ ## Données enregistrées
-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. +Après avoir activé la journalisation W&B, 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, afin de conserver un enregistrement de la configuration de chaque run à côté de ses métriques. 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). @@ -95,21 +99,21 @@ W&B capture la configuration résolue dans l’onglet **Aperçu**. W&B s ### 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 : +Chaque recette a sa propre boucle d’entraînement. Consultez chaque recette pour voir les 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`. | +| Métrique | Description | +| ------------------- | ----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | +| `loss` | La perte du modèle. | +| `lr` | Le taux d’apprentissage. | +| `tokens_per_second` | Le nombre de jetons par seconde du modèle. | +| `grad_norm` | La norme du gradient du modèle. | +| `global_step` | Correspond à l’étape actuelle de la boucle d’entraînement. Tient compte de l’accumulation des gradients. Chaque fois qu’une étape de l’optimiseur s’exécute, le modèle est mis à jour, les gradients s’accumulent, et le modèle est mis à jour 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. + `global_step` n'est pas identique au nombre d’étapes d’entraînement. Il correspond à l’étape actuelle de la boucle d’entraînement et tient compte de l’accumulation des gradients. Chaque fois qu’une étape de l’optimiseur s’exécute, `global_step` est incrémenté de 1. Par exemple, si le chargeur de données comporte 10 lots, que le nombre d’étapes d’accumulation des gradients est de 2 et que vous exécutez 3 époques, l’optimiseur effectue 15 étapes, donc `global_step` va 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 : +La conception de torchtune vous permet d’ajouter des métriques personnalisées ou de modifier celles qui existent déjà. Modifiez le [fichier de recette](https://github.com/meta-pytorch/torchtune/tree/main/recipes) correspondant. Par exemple, vous pouvez enregistrer `current_epoch` en pourcentage du nombre total d’époques comme ceci : ```python # dans la fonction `train.py` du fichier de recette @@ -120,34 +124,36 @@ self._metric_logger.log_dict( ``` - 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.*`. + L’ensemble des métriques enregistrées peut varier d’une version de torchtune à l’autre. Pour ajouter une métrique personnalisée, modifiez la recette et appelez la fonction `self._metric_logger.*` correspondante.
- ## Enregistrer et charger des points de contrôle + ## Enregistrer et charger des points de contrôle du modè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. +Enregistrez les points de contrôle du modèle dans W&B Artifacts pour versionner les poids du modèle en même temps que les métriques et la configuration de chaque run, afin de pouvoir reproduire les résultats et comparer les versions du modèle ultérieurement. -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. +La bibliothèque torchtune prend en charge plusieurs [formats de point de contrôle du modè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 checkpointer](https://meta-pytorch.org/torchtune/stable/deep_dives/checkpointer.html) appropriée. -Voici un exemple montrant comment surcharger la fonction `save_checkpoint` pour enregistrer les points de contrôle du modèle dans W&B Artifacts. +Pour enregistrer les points de contrôle du modèle du modèle dans [W&B Artifacts](/fr/models/artifacts/), l’approche recommandée consiste à redéfinir les fonctions `save_checkpoint` de la recette correspondante. + +L’exemple suivant montre comment redéfinir la fonction `save_checkpoint` pour enregistrer les points de contrôle du modèle du modèle dans W&B Artifacts. ```python 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 + ## Enregistrez le point de contrôle du modèle dans W&B. + ## Le nom du fichier dépend de la classe Checkpointer. + ## 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 du point de contrôle du modèle du modèle description="Model checkpoint", - # vous pouvez ajouter toutes les métadonnées souhaitées sous forme de dict + # vous pouvez ajouter les métadonnées de votre choix sous forme de dictionnaire metadata={ utils.SEED_KEY: self.seed, utils.EPOCHS_KEY: self.epochs_run, @@ -157,4 +163,4 @@ def save_checkpoint(self, epoch: int) -> None: ) wandb_artifact.add_file(checkpoint_file) wandb.log_artifact(wandb_artifact) -``` +``` \ No newline at end of file diff --git a/fr/models/integrations/ultralytics.mdx b/fr/models/integrations/ultralytics.mdx index d82f00bae0..538799404b 100644 --- a/fr/models/integrations/ultralytics.mdx +++ b/fr/models/integrations/ultralytics.mdx @@ -7,32 +7,40 @@ import { ColabLink } from '/snippets/fr/_includes/colab-link.mdx'; -[Ultralytics](https://github.com/ultralytics/ultralytics) est la référence pour les modèles de vision par ordinateur de pointe destinés à des tâches comme la classification d’images, la détection d’objets, la segmentation d’images et l’estimation de pose. Il héberge non seulement [YOLOv8](https://docs.ultralytics.com/models/yolov8/), la dernière itération de la série YOLO de modèles de détection d’objets en temps réel, mais aussi d’autres modèles puissants de vision par ordinateur comme [SAM (Segment Anything Model)](https://docs.ultralytics.com/models/sam/#introduction-to-sam-the-segment-anything-model), [RT-DETR](https://docs.ultralytics.com/models/rtdetr/), [YOLO-NAS](https://docs.ultralytics.com/models/yolo-nas/), etc. En plus de proposer des implémentations de ces modèles, Ultralytics fournit également des flux de travail prêts à l’emploi pour entraîner, effectuer le Fine-tuning et utiliser ces modèles à l’aide d’une API simple d’utilisation. +[Ultralytics](https://github.com/ultralytics/ultralytics) fournit des modèles de vision par ordinateur pour des tâches comme la classification d’images, la détection d’objets, la segmentation d’images et l’estimation de pose. Il héberge [YOLOv8](https://docs.ultralytics.com/models/yolov8/), une itération de la série YOLO de modèles de détection d’objets en temps réel, ainsi que d’autres modèles de vision par ordinateur tels que [SAM (Segment Anything Model)](https://docs.ultralytics.com/models/sam/#introduction-to-sam-the-segment-anything-model), [RT-DETR](https://docs.ultralytics.com/models/rtdetr/) et [YOLO-NAS](https://docs.ultralytics.com/models/yolo-nas/). Ultralytics fournit également des flux de travail prêts à l’emploi pour entraîner, effectuer le fine-tuning et utiliser ces modèles via une API. + +Cette page vous montre comment intégrer W&B à Ultralytics afin que W&B suive et visualise automatiquement les métriques d’expérience, les points de contrôle du modèle et les prédictions sur des images de validation ou d’inférence. Elle couvre l’installation, un flux de travail d’entraînement et de validation, ainsi qu’un flux de travail dédié uniquement à l’inférence.
## Premiers pas
-1. Installez `ultralytics` et `wandb`. +Pour utiliser l’intégration, vous devez d’abord installer `ultralytics` et `wandb`, puis vérifier que vous utilisez une version de `ultralytics` prise en charge. + +Installez `ultralytics` et `wandb` : + + + + ```shell + pip install --upgrade ultralytics==8.0.238 wandb - - - ```shell - pip install --upgrade ultralytics==8.0.238 wandb + # ou + # conda install ultralytics + ``` + - # ou - # conda install ultralytics - ``` - + + ```bash + !pip install --upgrade ultralytics==8.0.238 wandb + ``` + + - - ```bash - !pip install --upgrade ultralytics==8.0.238 wandb - ``` - - + + L'équipe de développement a testé l'intégration avec `ultralytics` v8.0.238 et les versions antérieures. Pour signaler tout problème lié à l'intégration, créez une [GitHub issue](https://github.com/wandb/wandb/issues/new?template=sdk-bug.yml) avec le tag `yolov8`. + - L'équipe de développement a testé l'intégration avec `ultralyticsv8.0.238` et les versions antérieures. Pour signaler tout problème lié à l'intégration, créez une [GitHub issue](https://github.com/wandb/wandb/issues/new?template=sdk-bug.yml) avec le tag `yolov8`. +Une fois les deux packages installés, vous pouvez passer à l’instrumentation d’un flux de travail Ultralytics avec W&B.
## Suivre les expériences et visualiser les résultats de validation @@ -40,11 +48,11 @@ import { ColabLink } from '/snippets/fr/_includes/colab-link.mdx'; -Cette section présente un flux de travail typique qui consiste à utiliser un modèle [Ultralytics](https://docs.ultralytics.com/modes/predict/) pour l'entraînement, le fine-tuning et la validation, ainsi qu'à effectuer le suivi des expériences, l'enregistrement de point de contrôle du modèle et la visualisation des performances du modèle avec [W&B](https://wandb.ai/site). +Cette section présente un flux de travail typique qui utilise un modèle [Ultralytics](https://docs.ultralytics.com/modes/predict/) pour l’entraînement, le fine-tuning et la validation, et qui assure le suivi des expériences, l’enregistrement des points de contrôle du modèle et la visualisation des performances du modèle avec [W&B](https://wandb.ai/site). -Vous pouvez également en savoir plus sur l'intégration dans ce rapport : [Supercharging Ultralytics with W&B](https://wandb.ai/geekyrakshit/ultralytics/reports/Supercharging-Ultralytics-with-Weights-Biases--Vmlldzo0OTMyMDI4) +Pour plus d’informations sur l’intégration, voir [Supercharging Ultralytics with W&B](https://wandb.ai/geekyrakshit/ultralytics/reports/Supercharging-Ultralytics-with-Weights-Biases--Vmlldzo0OTMyMDI4). -Pour utiliser l'intégration W&B avec Ultralytics, importez la fonction `wandb.integration.ultralytics.add_wandb_callback`. +Pour utiliser l’intégration W&B avec Ultralytics, importez la fonction `wandb.integration.ultralytics.add_wandb_callback`. Cette fonction de rappel constitue le point d’entrée qui enregistre la journalisation W&B pour le modèle Ultralytics. ```python import wandb @@ -53,7 +61,7 @@ from wandb.integration.ultralytics import add_wandb_callback from ultralytics import YOLO ``` -Initialisez le modèle `YOLO` de votre choix, puis appelez la fonction `add_wandb_callback` sur celui-ci avant d'exécuter une inférence avec le modèle. Cela garantit que, lors de l'entraînement, du fine-tuning, de la validation ou de l'inférence, les logs de l'expérience ainsi que les images avec la vérité terrain et les résultats de prédiction correspondants superposés sont automatiquement enregistrés dans W&B à l'aide des [superpositions interactives pour les tâches de vision par ordinateur](/fr/models/track/log/media/#image-overlays-in-tables), ainsi que des informations supplémentaires dans un [`wandb.Table`](/fr/models/tables/). +Ensuite, initialisez le modèle `YOLO` de votre choix, puis appelez la fonction `add_wandb_callback` sur ce modèle avant d’effectuer une inférence. Joindre le callback avant l’entraînement active la journalisation automatique à chaque époque. Ainsi, lorsque vous effectuez un entraînement, du fine-tuning, une validation ou une inférence, W&B enregistre automatiquement les journaux de l’expérience ainsi que les images, avec les annotations de référence et les résultats de prédiction correspondants superposés à l’aide des [superpositions interactives pour les tâches de vision par ordinateur](/fr/models/track/log/media/#image-overlays-in-tables), ainsi que des informations supplémentaires dans un [`wandb.Table`](/fr/models/tables/). ```python with wandb.init(project="ultralytics", job_type="train") as run: @@ -64,20 +72,22 @@ with wandb.init(project="ultralytics", job_type="train") as run: # Ajouter le callback W&B pour Ultralytics add_wandb_callback(model, enable_model_checkpointing=True) - # Entraîner/affiner votre modèle + # Entraîner votre modèle / effectuer le fine-tuning # À la fin de chaque époque, les prédictions sur les lots de validation sont enregistrées # dans un tableau W&B avec des superpositions interactives et pertinentes pour # les tâches de vision par ordinateur model.train(project="ultralytics", data="coco128.yaml", epochs=5, imgsz=640) ``` -Voici à quoi ressemblent les expériences suivies avec W&B dans un flux de travail Ultralytics d'entraînement ou de fine-tuning : +Une fois le callback ajouté et l'entraînement démarré, votre run envoie désormais en continu les métriques d'entraînement, les points de contrôle du modèle et les visualisations de validation pour chaque époque vers votre projet W&B. + +Voici à quoi ressemblent les expériences suivies avec W&B dans un flux de travail d'entraînement ou de fine-tuning avec Ultralytics :
Expériences de fine-tuning YOLO