> ## Documentation Index > Fetch the complete documentation index at: https://wb-21fd5541-update-regex-mention.mintlify.site/llms.txt > Use this file to discover all available pages before exploring further. # Hugging Face Transformers > Utilisez W&B avec Hugging Face Transformers Trainer pour le suivi des expériences, les points de contrôle du modèle et la gestion des versions des jeux de données. export const ColabLink = ({url}) => Essayer sur Colab ; 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. 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 theme={null} 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 args = TrainingArguments(..., report_to="wandb") # activer la journalisation W&B trainer = Trainer(..., args=args) ``` 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).
## 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
Une clé API permet d'authentifier votre machine auprès de W\&B. Vous pouvez générer une clé API depuis votre profil. Pour une méthode plus directe, accédez aux [Paramètres utilisateur](https://wandb.ai/settings) et créez une clé API. Copiez immédiatement la clé API et conservez-la dans un endroit sûr, par exemple dans un gestionnaire de mots de passe. 1. Cliquez sur l'icône de votre profil dans le coin supérieur droit. 2. Sélectionnez **Paramètres utilisateur**, puis faites défiler jusqu'à la section **Clés API**.
### Installez la bibliothèque `wandb` et connectez-vous
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. Remplacez les valeurs entre `<>` par les vôtres : ```bash theme={null} export WANDB_API_KEY= ``` 2. Installez la bibliothèque `wandb` et connectez-vous. ```bash theme={null} pip install wandb wandb login ``` ```bash theme={null} pip install wandb ``` ```python theme={null} import wandb wandb.login() ``` ```notebook theme={null} !pip install wandb import wandb wandb.login() ``` 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 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 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. ```bash theme={null} WANDB_PROJECT=amazon_sentiment_analysis ``` ```python theme={null} import os os.environ["WANDB_PROJECT"]="amazon_sentiment_analysis" ``` ```notebook theme={null} %env WANDB_PROJECT=amazon_sentiment_analysis ``` Assurez-vous de définir le nom du projet *avant* d’initialiser le `Trainer`. 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, 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 journalisent les pertes, les métriques d'évaluation, l'architecture du modèle et les gradients dans W\&B pendant leur entraînement. ```bash theme={null} python run_glue.py \ # exécutez votre script Python --report_to wandb \ # activez la journalisation vers W&B --run_name bert-base-high-lr \ # nom du run W&B (facultatif) # autres arguments de ligne de commande ici ``` ```python theme={null} 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 ) 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 ``` Vous utilisez TensorFlow ? Remplacez le `Trainer` de PyTorch par le `TFTrainer` de TensorFlow.
### Activez l'enregistrement des points de contrôle du modèle
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. ```bash theme={null} WANDB_LOG_MODEL="checkpoint" ``` ```python theme={null} import os os.environ["WANDB_LOG_MODEL"] = "checkpoint" ``` ```notebook theme={null} %env WANDB_LOG_MODEL="checkpoint" ``` 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 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
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 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. 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. 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). Affiche un tableau W&B avec des sorties d’évaluation
### Terminez votre run W\&B (notebook uniquement)
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, appelez `run.finish()` pour indiquer que l’entraînement est terminé. ```python theme={null} run = wandb.init() trainer.train() # démarrer l'entraînement et la journalisation vers W&B # analyse post-entraînement, tests, autre code enregistré run.finish() ```
### Visualisez vos résultats
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
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. Si vous enregistrez les points de contrôle de votre modèle dans Artifacts, vous pouvez les promouvoir vers le [registre](/fr/models/registry/). Dans le registre, vous pouvez : * Organiser les versions de votre meilleur modèle par tâche de ML. * Centraliser les modèles et les partager avec votre équipe. * Préparer les modèles pour la production ou les marquer pour une évaluation plus approfondie. * Déclencher des processus CI/CD en aval.
### 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. Rechargez-les dans la même architecture Hugging Face que celle utilisée précédemment. ```python theme={null} # Créer un nouveau run with wandb.init(project="amazon_sentiment_analysis") as run: # Indiquer le nom et la version de l'Artifact my_model_name = "model-bert-base-high-lr:latest" my_model_artifact = run.use_artifact(my_model_name) # Télécharger les poids du modèle dans un dossier et retourner le chemin model_dir = my_model_artifact.download() # Charger votre modèle Hugging Face depuis ce dossier # en utilisant la même classe de modèle model = AutoModelForSequenceClassification.from_pretrained( model_dir, num_labels=num_labels ) # Effectuer un entraînement supplémentaire ou exécuter l'inférence ```
### Reprendre l’entraînement à partir d’un point de contrôle
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 theme={null} last_run_id = "xxxxxxxx" # fetch the run_id from your wandb workspace # resume the wandb run from the run_id with wandb.init( project=os.environ["WANDB_PROJECT"], id=last_run_id, resume="must", ) as run: # Connect an Artifact to the run my_checkpoint_name = f"checkpoint-{last_run_id}:latest" my_checkpoint_artifact = run.use_artifact(my_checkpoint_name) # Download checkpoint to a folder and return the path checkpoint_dir = my_checkpoint_artifact.download() # reinitialize your model and trainer model = AutoModelForSequenceClassification.from_pretrained( "", num_labels=num_labels ) # vos arguments d'entraînement ici. training_args = TrainingArguments() trainer = Trainer(model=model, args=training_args) # make sure use the checkpoint dir to resume training from the checkpoint trainer.train(resume_from_checkpoint=checkpoint_dir) ```
### Journaliser et afficher des échantillons d’évaluation pendant l’entraînement
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 Hugging Face Trainer, suivi d’un exemple de code complet pour journaliser les sorties d’évaluation dans un tableau W\&B : ```python theme={null} # Instancier le Trainer normalement trainer = Trainer() # Instancier le nouveau callback de journalisation en lui passant l'objet Trainer evals_callback = WandbEvalsCallback(trainer, tokenizer, ...) # Ajouter le callback au Trainer trainer.add_callback(evals_callback) # Lancer l'entraînement du Trainer normalement 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. Cela s’exécute tous les `eval_steps` en utilisant la méthode `on_evaluate` du callback du `Trainer`. La fonction `decode_predictions` décode les prédictions et les labels à partir de la sortie du modèle à l’aide du tokenizer. Ensuite, le code crée un dataframe pandas à partir des prédictions et des labels, puis ajoute une colonne `epoch` au dataframe. 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. 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 theme={null} from transformers.integrations import WandbCallback import pandas as pd def decode_predictions(tokenizer, predictions): labels = tokenizer.batch_decode(predictions.label_ids) logits = predictions.predictions.argmax(axis=-1) prediction_text = tokenizer.batch_decode(logits) return {"labels": labels, "predictions": prediction_text} class WandbPredictionProgressCallback(WandbCallback): """Custom WandbCallback to log model predictions during training. This callback logs model predictions and labels to a wandb.Table at each logging step during training. It allows to visualize the model predictions as the training progresses. Attributes: trainer (Trainer): The Hugging Face Trainer instance. tokenizer (AutoTokenizer): The tokenizer associated with the model. sample_dataset (Dataset): A subset of the validation dataset for generating predictions. num_samples (int, optional): Number of samples to select from the validation dataset for generating predictions. Defaults to 100. freq (int, optional): Frequency of logging. Defaults to 2. """ def __init__(self, trainer, tokenizer, val_dataset, num_samples=100, freq=2): """Initializes the WandbPredictionProgressCallback instance. Args: trainer (Trainer): The Hugging Face Trainer instance. tokenizer (AutoTokenizer): The tokenizer associated with the model. val_dataset (Dataset): The validation dataset. num_samples (int, optional): Number of samples to select from the validation dataset for generating predictions. Defaults to 100. freq (int, optional): Frequency of logging. Defaults to 2. """ super().__init__() self.trainer = trainer self.tokenizer = tokenizer self.sample_dataset = val_dataset.select(range(num_samples)) self.freq = freq def on_evaluate(self, args, state, control, **kwargs): super().on_evaluate(args, state, control, **kwargs) # contrôler la fréquence de journalisation en journalisant les prédictions # toutes les `freq` époques if state.epoch % self.freq == 0: # générer les prédictions predictions = self.trainer.predict(self.sample_dataset) # décoder les prédictions et les labels predictions = decode_predictions(self.tokenizer, predictions) # ajouter les prédictions à un wandb.Table predictions_df = pd.DataFrame(predictions) predictions_df["epoch"] = state.epoch records_table = self._wandb.Table(dataframe=predictions_df) # journaliser le tableau dans wandb self._wandb.log({"sample_predictions": records_table}) # D'abord, instancier le Trainer trainer = Trainer( model=model, args=training_args, train_dataset=lm_datasets["train"], eval_dataset=lm_datasets["validation"], ) # Instancier le WandbPredictionProgressCallback progress_callback = WandbPredictionProgressCallback( trainer=trainer, tokenizer=tokenizer, val_dataset=lm_dataset["validation"], num_samples=10, freq=2, ) # Ajouter le callback au trainer trainer.add_callback(progress_callback) ``` 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).
### 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. 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) | ```bash theme={null} WANDB_WATCH=all WANDB_SILENT=true ``` ```notebook theme={null} %env WANDB_WATCH=all %env WANDB_SILENT=true ```
### 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). ```python theme={null} wandb.init( project="amazon_sentiment_analysis", name="bert-base-high-lr", tags=["baseline", "high-lr"], group="bert", ) ```
## Ressources supplémentaires
Pour aller plus loin, voici six articles sur Transformers et W\&B.
Optimisation des hyperparamètres pour les Transformers de 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. 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 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. 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 W\&B * 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. 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 * 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. 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é avec HuggingFace * 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. 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 des Transformers de Hugging Face sur un dataset personnalisé Effectue le fine-tuning d’un modèle DistilBERT pour l’analyse de sentiment (classification binaire) sur un dataset IMDB personnalisé. 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, 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.