Bonjour, il s'agit d'une vidéo sur l'API `push_to_hub` pour Tensorflow et Keras. Donc,
pour commencer, nous allons ouvrir notre notebook, et la première chose que vous devrez faire est de vous
connecter à votre compte HuggingFace, par exemple avec la fonction de connexion du notebook. Donc, pour ce faire,
vous appelez simplement la fonction, la fenêtre contextuelle apparaîtra, vous entrez votre nom d'utilisateur et votre mot de passe,
que je vais retirer de mon gestionnaire de mots de passe ici, et vous êtes connecté. Les
deux cellules suivantes préparent tout ce qu'il faut pour l'entraînement. Nous allons donc simplement charger un jeu de données,
nous allons tokeniser ce jeu de données, puis nous allons charger notre modèle et le compiler
avec l'optimiseur Adam standard. Je vais donc tout exécuter.
Nous attendrons quelques secondes et tout devrait être prêt pour l'entraînement.
D'accord, nous sommes maintenant prêts pour entraîner. Je vais vous montrer les deux manières de
transférer votre modèle vers le Hub. Donc, la première est avec `PushToHubCallback`.
Ainsi, un « Callback » dans Keras est une fonction qui est appelée régulièrement pendant l'entraînement. Vous pouvez la configurer pour qu'elle soit
appelé après un certain nombre d'étapes, ou à chaque époque, ou même une seule fois à la fin de l'entraînement.
Ainsi, de nombreux « Callback » dans Keras, par exemple, contrôlent le taux 'apprentissage de décroissance sur plateau
et des choses comme ça. Et donc ce « Callback », par défaut, enregistrera votre modèle dans le Hub une fois à
chaque époque. Et c'est vraiment utile, surtout si votre entraînement est très long, car cela signifie que
vous pouvez reprendre à partir de cette sauvegarde, donc vous obtenez cette sauvegarde automatique de votre modèle dans le cloud, et vous pouvez
même exécuter une inférence avec les checkpoints de votre modèle qui ont été téléchargés par ce « Callback ».
Et cela signifie que vous pouvez, vous savez, exécuter des entrées de test et voir réellement comment
votre modèle fonctionne à différentes étapes de l'entraînement, ce qui est une fonctionnalité vraiment intéressante.
Nous allons donc ajouter le `PushToHubCallback` qui ne prend que quelques arguments. Le premier argument
est donc le répertoire temporaire dans lequel les fichiers vont être enregistrés avant d'être téléchargés sur le Hub.
Le deuxième argument est le tokenizer, et le troisième argument ici est l'argument mot clé
`hub_model_id`. C'est donc le nom sous lequel il sera enregistré sur le Hub d'HuggingFace.
Vous pouvez également télécharger vers un compte d'organisation en ajoutant simplement le nom de l'organisation avant
le nom du dépôt avec une barre oblique comme celle-ci. Vous n'avez donc probablement pas les autorisations pour télécharger vers
l'organisation Hugging Face, si vous le faites, veuillez signaler un bogue et nous le faire savoir de toute urgence.
Mais si vous avez accès à votre propre organisation, vous pouvez utiliser la
même approche pour télécharger des modèles sur leur compte plutôt que sur votre propre
jeu de modèles. Ainsi, une fois que vous avez effectué votre `callbacks`, vous l'ajoutez simplement à la liste `callbacks`
lorsque vous êtes appelé `model.fit()` et tout est téléchargé pour vous à partir de là, et vous n'avez
plus à vous inquiéter. La deuxième façon d'importer un modèle consiste à appeler `model.push_to_hub()`.
Il s'agit donc plutôt d'une méthode ponctuelle : elle n'est pas appelée régulièrement pendant l'entraînement. Vous pouvez simplement
l'appeler manuellement chaque fois que vous souhaitez télécharger un modèle sur le Hub. Nous vous recommandons donc de l'exécuter
après la fin de l'entraînement, juste vous assurer que vous avez un message de commit pour garantir
qu'il s'agissait de la version finale du modèle, à la fin de l'entraînement. Et cela garantit simplement que
vous travaillez avec le modèle d'entraînement définitif et que vous n'utilisez pas accidentellement un modèle
provenant d'un checkpoint quelque part en cours de route. Je vais donc exécuter ces deux cellules
puis je vais couper la vidéo ici, simplement parce que l'entraînement va prendre quelques
minutes, et je vais donc passer à la fin de cela, lorsque les modèles ont tous été téléchargés,
et je vais vous montrer comment vous pouvez accéder aux modèles dans le Hub et les autres choses que
vous pouvez faire avec eux à partir de là. D'accord, nous sommes de retour et notre modèle a été téléchargé, à la
fois par le `PushToHubCallback` et également par notre appel à `model.push_to_hub()` après l'entraînement.
Donc tout s'annonce bien ! Alors maintenant, si nous passons sur mon profil sur HuggingFace, que vous pouvez
y accéder en cliquant simplement sur le bouton de profil dans le menu déroulant, nous pouvons voir que le modèle `bert-fine-tuned-
cola` est ici et a été mis à jour il y a 3 minutes. Il figurera donc toujours en haut de votre liste, car
ils sont triés en fonction de leur date de mise à jour récente. Et nous pouvons commencer à interroger notre modèle immédiatement !
Le jeu de données sur lequel nous avons entraîné est donc le jeu de données GLUE CoLA, et CoLA est l'acronyme de « Corpus
of Linguistic Acceptability ». Cela signifie donc que le modèle est entraîné pour décider si une
phrase est grammaticalement ou linguistiquement correcte, ou s'il y a un problème avec elle. Par exemple,
nous pourrions dire « This is a legitimate sentence » et nous espérons qu'il réalise qu'il s'agit en
fait d'une phrase légitime. Donc, le chargement du modèle peut prendre quelques secondes lorsque vous
l'appelez pour la première fois. Je peux donc supprimer quelques secondes de cette vidéo ici.
Ok, nous sommes de retour ! Le modèle a été chargé et nous avons obtenu un résultat, mais il y a un problème évident ici.
Ces étiquettes ne nous indiquent donc pas vraiment quelles catégories le modèle a réellement attribuées à
cette phrase d'entrée. Donc, si nous voulons résoudre ce problème, nous voulons nous assurer que la configuration du modèle a les
noms corrects pour chacune des classes d'étiquettes, puis nous voulons importer cette configuration. Nous pouvons donc le faire
ici. Pour obtenir les `label_names`, nous pouvons les obtenir à partir du jeu de données que nous avons chargé, à partir de l'attribut `.features` dont
il dispose. Et puis nous pouvons créer des dictionnaires `id2label` et `label2id`
et les attribuer simplement à la configuration du modèle. Puis nous pouvons simplement pousser notre configuration mise à jour et cela
remplacera la configuration existante dans le dépôt sur le Hub. Donc cela vient d'être fait. Donc maintenant si nous revenons ici,
je vais utiliser une phrase légèrement différente parce que les sorties pour les phrases sont parfois
mises en cache, et donc si nous voulons générer de nouveaux résultats je vais utiliser quelque chose de légèrement différent.
Essayons donc une phrase incorrecte, donc ce n'est pas une grammaire anglaise valide et j'espère que le modèle le
verra. Il va se recharger ici, donc je vais couper quelques secondes ici,
et ensuite nous verrons ce que le modèle va dire. Ok ! La confiance du modèle n'est donc pas très bonne
car bien sûr nous n'avons pas du tout optimisé nos hyperparamètres, mais il a décidé que
cette phrase est plus susceptible d'être inacceptable qu'acceptable. Vraisemblablement, si nous essayions un peu
plus avec l'entraînement, nous pourrions obtenir une perte de validation beaucoup plus faible et donc les prédictions du modèle
seraient plus précises. Mais essayons à nouveau notre phrase d'origine. Bien sûr, en
raison du problème de mise en cache, nous constatons que les réponses d'origine sont inchangées.
Essayons donc une phrase différente et valide. Essayons donc « This is a valid English sentence. ».
Et nous voyons que maintenant le modèle décide correctement qu'il a une très forte probabilité d'être
acceptable et une très faible probabilité d'être inacceptable. Vous pouvez donc utiliser cette API d'inférence
même avec les checkpoints téléchargés pendant l'entraînement. Il peut donc être très intéressant de voir comment
les prédictions du modèle pour les exemples d'entrées changent à chaque époque d'entraînement.
De plus, le modèle que nous avons importé sera accessible pour vous et, s'il est partagé publiquement,
par n'importe qui d'autre. Donc, si vous voulez charger ce modèle, tout ce que vous ou quelqu'un d'autre devez faire
est de le charger dans un pipeline ou vous pouvez simplement le charger avec, par exemple,
`TFAutoModelForSequenceClassification`. Puis pour le nom, vous passerez simplement le chemin
vers le dépôt que vous souhaitez charger - ou télécharger, excusez-moi. Donc, si je veux utiliser à nouveau ce modèle,
si je veux le télécharger à partir du Hub, j'exécute simplement cette une ligne de code, le modèle sera téléchargé
et avec un peu de chance, il sera prêt à être finetuner sur un autre jeu de données,
faire des prédictions avec ou faire tout ce que vous voulez faire. C'était donc un bref aperçu de la manière dont,
après ou pendant votre entraînement, vous pouvez télécharger des modèles dans le Hub.
Vous pouvez le sauvegarder, vous pouvez reprendre l'entraînement à partir de là et vous pouvez obtenir des résultats d'inférence à partir
des modèles que vous avez téléchargés. Alors merci, et j'espère vous voir dans une future vidéo !