Présentation

Dans cet atelier, vous allez apprendre à utiliser Vertex AI afin d'exécuter un job de réglage des hyperparamètres pour un modèle TensorFlow. Bien que cet atelier utilise TensorFlow pour le code du modèle, vous pourriez facilement le remplacer par un autre framework.

Objectifs de la formation

• Créer un notebook d'instance Workbench
• Modifier le code de l'application d'entraînement pour les réglages des hyperparamètres
• Lancer un job de réglage des hyperparamètres à partir de l'interface utilisateur de Vertex AI

Présentation de Vertex AI

Cet atelier utilise la toute dernière offre de produits d'IA de Google Cloud. Vertex AI simplifie l'expérience de développement en intégrant toutes les offres de ML de Google Cloud. Auparavant, les modèles entraînés avec AutoML et les modèles personnalisés étaient accessibles depuis des services distincts. La nouvelle offre regroupe ces deux types de modèles mais aussi d'autres nouveaux produits en une seule API. Vous pouvez également migrer des projets existants vers Vertex AI. Pour envoyer un commentaire, consultez la page d'assistance.

Vertex AI comprend de nombreux produits différents qui permettent de gérer les workflows de ML de bout en bout. Cet atelier se concentre sur les produits mis en évidence ci-dessous : l'entraînement, le réglage des hyperparamètres et Notebooks.

Vertex AI propose deux solutions de notebook, Workbench et Colab Enterprise.

Workbench

Vertex AI Workbench constitue un excellent choix pour les projets où la priorité est donnée au contrôle et à la personnalisation. Il convient particulièrement aux projets élaborés composés de plusieurs fichiers, avec des dépendances complexes. C'est également un bon choix pour un data scientist qui passe d'une station de travail ou d'un ordinateur portable au cloud.

Les instances Vertex AI Workbench sont fournies avec une suite préinstallée de packages de deep learning, assurant la compatibilité avec les frameworks TensorFlow et PyTorch.

Préparation

Pour chaque atelier, nous vous attribuons un nouveau projet Google Cloud et un nouvel ensemble de ressources pour une durée déterminée, sans frais.

1. Connectez-vous à Qwiklabs dans une fenêtre de navigation privée.

2. Vérifiez le temps imparti pour l'atelier (par exemple : 01:15:00) : vous devez pouvoir le terminer dans ce délai.
   Une fois l'atelier lancé, vous ne pouvez pas le mettre en pause. Si nécessaire, vous pourrez le redémarrer, mais vous devrez tout reprendre depuis le début.

3. Lorsque vous êtes prêt, cliquez sur Démarrer l'atelier.

4. Notez vos identifiants pour l'atelier (Nom d'utilisateur et Mot de passe). Ils vous serviront à vous connecter à Google Cloud Console.

5. Cliquez sur Ouvrir la console Google.

6. Cliquez sur Utiliser un autre compte, puis copiez-collez les identifiants de cet atelier lorsque vous y êtes invité.
   Si vous utilisez d'autres identifiants, des messages d'erreur s'afficheront ou des frais seront appliqués.

7. Acceptez les conditions d'utilisation et ignorez la page concernant les ressources de récupération des données.

Activer l'API Compute Engine

1. Dans Cloud Console, cliquez sur le menu de navigation > API et services > Bibliothèque.

2. Recherchez l'API Compute Engine, puis cliquez sur Activer si elle n'est pas déjà activée. Vous en aurez besoin pour créer votre instance de notebook.

Activer l'API Container Registry

1. Dans Cloud Console, cliquez sur le menu de navigation > API et services > Bibliothèque.

2. Recherchez l'API Google Container Registry, puis cliquez sur Activer si elle n'est pas déjà activée. Vous l'utiliserez afin de créer un conteneur pour votre job d'entraînement personnalisé.

Tâche 1 : Lancer une instance Vertex AI Workbench

1. Dans le menu de navigation () de la console Google Cloud, sélectionnez Vertex AI.

2. Cliquez sur Activer toutes les API recommandées.

3. Dans le menu de navigation, cliquez sur Workbench.

   En haut de la page "Workbench", vérifiez que vous vous trouvez dans la vue Instances.

4. Cliquez sur Créer.

5. Configurez l'instance :

   • Nom : lab-workbench
   • Région : définissez la région sur
   • Zone : définissez la zone sur
   • Options avancées (facultatif) : si nécessaire, cliquez sur "Options avancées" pour une personnalisation plus avancée (par exemple, type de machine, taille du disque).

6. Cliquez sur Créer.

La création de l'instance prend quelques minutes. Une coche verte apparaît à côté de son nom quand elle est prête.

7. Cliquez sur OUVRIR JUPYTERLAB à côté du nom de l'instance pour lancer l'interface JupyterLab. Un nouvel onglet s'ouvre alors dans votre navigateur.

Remarque : Le modèle que vous allez entraîner et régler dans cet atelier est un modèle de classification d'images entraîné avec l'ensemble de données horses_or_humans de TensorFlow.

Cliquez sur Vérifier ma progression pour valider l'objectif. Lancer une instance Vertex AI Workbench

Tâche 2 : Conteneuriser le code de l'application d'entraînement

Vous allez envoyer ce job de réglage des hyperparamètres à Vertex en plaçant le code de votre application d'entraînement dans un conteneur Docker et en transférant ce conteneur vers Google Container Registry. Cette approche vous permet de régler les hyperparamètres d'un modèle créé avec n'importe quel framework.

1. Dans JupyterLab, accédez au menu de lancement et ouvrez une fenêtre de terminal dans votre instance de notebook.

2. Créez un répertoire appelé horses_or_humans et utilisez cd pour y accéder :

mkdir horses_or_humans cd horses_or_humans

Créer un fichier Dockerfile

La première étape de la conteneurisation de votre code consiste à créer un Dockerfile. Vous allez placer dans ce Dockerfile toutes les commandes nécessaires à l'exécution de l'image. Il installera toutes les bibliothèques requises, y compris la bibliothèque cloudml-hypertune, et configurera le point d'entrée du code d'entraînement.

1. Depuis votre terminal, créez un Dockerfile vide :

touch Dockerfile

2. Ouvrez le Dockerfile à partir du menu de gauche et copiez-y le code suivant :

FROM gcr.io/deeplearning-platform-release/tf2-gpu.2-9 WORKDIR / # Installs hypertune library RUN pip install cloudml-hypertune # Copies the trainer code to the docker image. COPY trainer /trainer # Sets up the entry point to invoke the trainer. ENTRYPOINT ["python", "-m", "trainer.task"]

3. Enregistrez le fichier en appuyant sur CTRL+S.

Ce Dockerfile utilise l'image Docker avec GPU de TensorFlow Enterprise 2.9 comme conteneur de deep learning. Les conteneurs de deep learning de Google Cloud sont fournis avec de nombreux frameworks de ML et de data science courants préinstallés.

Une fois cette image téléchargée, ce Dockerfile configure le point d'entrée du code d'entraînement. Vous n'avez pas encore créé ces fichiers. À la prochaine étape, vous allez ajouter le code d'entraînement et de réglage du modèle.

Ajouter le code d'entraînement du modèle

1. Depuis votre terminal, exécutez le code suivant afin de créer un répertoire pour le code d'entraînement et un fichier Python dans lequel vous ajouterez le code :

mkdir trainer touch trainer/task.py

Le contenu de votre répertoire horses_or_humans/ devrait maintenant correspondre à ce qui est indiqué ci-dessous :

+ Dockerfile + trainer/ + task.py

2. Ouvrez ensuite le fichier task.py que vous venez de créer et copiez-y le code ci-dessous :

import tensorflow as tf import tensorflow_datasets as tfds import argparse import hypertune NUM_EPOCHS = 10 def get_args(): '''Parses args. Must include all hyperparameters you want to tune.''' parser = argparse.ArgumentParser() parser.add_argument( '--learning_rate', required=True, type=float, help='learning rate') parser.add_argument( '--momentum', required=True, type=float, help='SGD momentum value') parser.add_argument( '--num_neurons', required=True, type=int, help='number of units in last hidden layer') args = parser.parse_args() return args def preprocess_data(image, label): '''Resizes and scales images.''' image = tf.image.resize(image, (150,150)) return tf.cast(image, tf.float32) / 255., label def create_dataset(): '''Loads Horses Or Humans dataset and preprocesses data.''' data, info = tfds.load(name='horses_or_humans', as_supervised=True, with_info=True) # Create train dataset train_data = data['train'].map(preprocess_data) train_data = train_data.shuffle(1000) train_data = train_data.batch(64) # Create validation dataset validation_data = data['test'].map(preprocess_data) validation_data = validation_data.batch(64) return train_data, validation_data def create_model(num_neurons, learning_rate, momentum): '''Defines and complies model.''' inputs = tf.keras.Input(shape=(150, 150, 3)) x = tf.keras.layers.Conv2D(16, (3, 3), activation='relu')(inputs) x = tf.keras.layers.MaxPooling2D((2, 2))(x) x = tf.keras.layers.Conv2D(32, (3, 3), activation='relu')(x) x = tf.keras.layers.MaxPooling2D((2, 2))(x) x = tf.keras.layers.Conv2D(64, (3, 3), activation='relu')(x) x = tf.keras.layers.MaxPooling2D((2, 2))(x) x = tf.keras.layers.Flatten()(x) x = tf.keras.layers.Dense(num_neurons, activation='relu')(x) outputs = tf.keras.layers.Dense(1, activation='sigmoid')(x) model = tf.keras.Model(inputs, outputs) model.compile( loss='binary_crossentropy', optimizer=tf.keras.optimizers.SGD(learning_rate=learning_rate, momentum=momentum), metrics=['accuracy']) return model def main(): args = get_args() train_data, validation_data = create_dataset() model = create_model(args.num_neurons, args.learning_rate, args.momentum) history = model.fit(train_data, epochs=NUM_EPOCHS, validation_data=validation_data) # DEFINE METRIC hp_metric = history.history['val_accuracy'][-1] hpt = hypertune.HyperTune() hpt.report_hyperparameter_tuning_metric( hyperparameter_metric_tag='accuracy', metric_value=hp_metric, global_step=NUM_EPOCHS) if __name__ == "__main__": main()

3. Enregistrez le fichier en appuyant sur CTRL+S.

Avant de créer le conteneur, examinons le code de plus près. Certains composants sont utilisés spécifiquement pour le service de réglage des hyperparamètres.

• Le script importe la bibliothèque hypertune. Notez que le Dockerfile de l'étape 1 contenait des instructions pour l'installation de cette bibliothèque avec pip.

• La fonction get_args() définit un argument de ligne de commande pour chaque hyperparamètre que vous voulez régler. Dans cet exemple, les hyperparamètres qui seront réglés sont le taux d'apprentissage, la valeur du Momentum dans l'optimiseur et le nombre de neurones dans la dernière couche cachée du modèle, mais n'hésitez pas à en tester d'autres. La valeur transmise dans ces arguments est ensuite utilisée pour définir l'hyperparamètre correspondant dans le code.

• À la fin de la fonction main(), la bibliothèque hypertune est utilisée pour définir la métrique que vous voulez optimiser. Dans TensorFlow, la méthode Keras model.fit renvoie un objet History. L'attribut History.history est un enregistrement des valeurs de perte d'entraînement et des métriques à des époques successives. Si vous transmettez des données de validation à model.fit, l'attribut History.history inclut également les valeurs de perte de validation et des métriques. Par exemple, si vous aviez entraîné un modèle pendant trois époques avec des données de validation et que vous aviez fourni accuracy (justesse) comme métrique, l'attribut History.history ressemblerait au dictionnaire suivant.

{ "accuracy": [ 0.7795261740684509, 0.9471358060836792, 0.9870933294296265 ], "loss": [ 0.6340447664260864, 0.16712145507335663, 0.04546636343002319 ], "val_accuracy": [ 0.3795261740684509, 0.4471358060836792, 0.4870933294296265 ], "val_loss": [ 2.044623374938965, 4.100203514099121, 3.0728273391723633 ]

Si vous voulez que le service de réglage des hyperparamètres découvre les valeurs qui maximisent la justesse de la validation du modèle, vous définissez la métrique comme dernière entrée (ou NUM_EPOCS - 1) de la liste val_accuracy. Vous transmettez ensuite cette métrique à une instance d'HyperTune. Vous pouvez choisir la chaîne que vous voulez pour hyperparameter_metric_tag, mais vous devrez la réutiliser ultérieurement lorsque vous lancerez le job de réglage des hyperparamètres.

Cliquez sur Vérifier ma progression pour valider l'objectif. Créer un fichier Dockerfile et ajouter le code d'entraînement du modèle

Créer le conteneur

1. Depuis votre terminal, exécutez le code suivant afin de définir une variable d'environnement pour votre projet, en veillant à remplacer your-cloud-project par l'ID de votre projet :

Remarque : Vous pouvez obtenir l'ID de votre projet en exécutant gcloud config list --format 'value(core.project)' dans votre terminal. PROJECT_ID='your-cloud-project'

2. Définissez une variable avec l'URI de votre image de conteneur dans Google Container Registry :

IMAGE_URI="gcr.io/$PROJECT_ID/horse-human:hypertune"

3. Créez ensuite le conteneur en exécutant le code suivant à partir de la racine de votre répertoire horses_or_humans :

docker build ./ -t $IMAGE_URI

4. Enfin, transférez-le vers Google Container Registry :

docker push $IMAGE_URI

Maintenant que le conteneur a été transféré vers Container Registry, vous êtes prêt à lancer un job de réglage des hyperparamètres d'un modèle personnalisé.

Cliquez sur Vérifier ma progression pour valider l'objectif. Créer le conteneur

Tâche 3 : Exécuter un job de réglage des hyperparamètres sur Vertex AI

Cet atelier utilise un entraînement personnalisé avec un conteneur personnalisé de Google Container Registry, mais vous pouvez également exécuter un job de réglage des hyperparamètres avec les conteneurs prédéfinis.

• Dans la console Cloud, accédez à la section Entraînement de Vertex AI.
• Pour l'API Vertex AI, cliquez sur Activer, puis sur Fermer.

Configurer le job d'entraînement

1. Cliquez sur Entraîner le nouveau modèle pour saisir les paramètres de votre job de réglage des hyperparamètres :

   • Sous Ensemble de données, sélectionnez Aucun ensemble de données géré.
   • Sélectionnez Entraînement personnalisé (avancé) comme méthode d'entraînement, puis cliquez sur Continuer.
   • Saisissez horses-humans-hyptertune (ou tout autre nom que vous voudriez donner à votre modèle) pour Nom du modèle.
   • Cliquez sur Continuer.

2. À l'étape Conteneur d'entraînement, sélectionnez Conteneur personnalisé :

   • Dans Paramètres du conteneur personnalisé, pour Image du conteneur, saisissez la valeur de votre variable IMAGE_URI de la section précédente. Il doit s'agir de gcr.io/<your-cloud-project>/horse-human:hypertune avec le nom de votre propre projet. Laissez les autres champs vides et cliquez sur Continuer.

Configurer le job de réglage des hyperparamètres

• Sélectionnez Activer le réglage des hyperparamètres.

Configurer les hyperparamètres

Vous devez ensuite ajouter les hyperparamètres que vous définissez comme arguments de ligne de commande dans le code de l'application d'entraînement. Lorsque vous ajoutez un hyperparamètre, vous devez d'abord en indiquer le nom. Celui-ci doit correspondre au nom d'argument que vous avez transmis à argparse.

1. Saisissez learning_rate pour Nom du paramètre.

2. Sélectionnez Double pour Type.

3. Saisissez 0,01 pour Min et 1 pour Max.

4. Sélectionnez Logarithme pour Scaling.

5. Cliquez sur OK.

6. Après avoir ajouté l'hyperparamètre learning_rate, ajoutez des paramètres pour momentum et num_neurons.

• Pour momentum :

  • Cliquez sur AJOUTER UN HYPERPARAMÈTRE.
  • Saisissez momentum pour Nom du paramètre.
  • Sélectionnez Double pour Type.
  • Saisissez 0 pour Min et 1 pour Max.
  • Sélectionnez Linéaire pour Scaling.
  • Cliquez sur OK.

• Pour num_neurons :

  • Cliquez sur AJOUTER UN HYPERPARAMÈTRE.
  • Saisissez num_neurons pour Nom du paramètre.
  • Sélectionnez Discret pour Type.
  • Saisissez 64 128 512 pour Valeurs.
  • Sélectionnez Aucun scaling pour Scaling.
  • Cliquez sur OK.

Configurer la métrique

Une fois que vous avez ajouté les hyperparamètres, vous devez fournir la métrique que vous voulez optimiser ainsi que l'objectif. La métrique doit être identique à la valeur que vous avez définie pour hyperparameter_metric_tag dans votre application d'entraînement.

1. Saisissez justesse pour Métrique à optimiser.
2. Sélectionnez Agrandir pour Objectif.

Le service de réglage des hyperparamètres de Vertex AI effectue plusieurs essais avec votre application d'entraînement en utilisant les valeurs configurées au cours des étapes précédentes. Vous devez fixer une limite pour que le service ne dépasse pas un certain nombre d'essais.

Un plus grand nombre d'essais permet généralement d'obtenir de meilleurs résultats, mais il existe un point de retours décroissants au-delà duquel les essais supplémentaires n'ont que peu ou pas d'effet sur la métrique que vous essayez d'optimiser. Il est recommandé de commencer avec un petit nombre d'essais et d'attendre d'avoir une idée du degré d'impact des hyperparamètres choisis pour passer à un grand nombre d'essais.

Vous devez également définir un nombre maximal d'essais parallèles. L'augmentation du nombre d'essais parallèles a pour effet de réduire le temps nécessaire à l'exécution du job de réglage des hyperparamètres. Toutefois, elle peut réduire l'efficacité globale du job. En effet, la stratégie de réglage par défaut utilise les résultats des essais précédents pour ajuster les valeurs affectées lors des essais suivants. Si vous exécutez un trop grand nombre d'essais en parallèle, certains essais démarreront sans bénéficier du résultat des essais qui sont toujours en cours d'exécution.

3. À titre de démonstration, vous pouvez définir le nombre maximal d'essais sur 15 et le nombre maximal d'essais parallèles sur 3. Vous pouvez faire des tests avec des valeurs différentes, mais cela risque d'allonger le temps de réglage et d'augmenter les coûts.

4. Sélectionnez Par défaut pour Algorithme. Ainsi, c'est avec Google Vizier que sera effectuée l'optimisation bayésienne pour le réglage des hyperparamètres. Pour en savoir plus sur cet algorithme, consultez l'article de blog Hyperparameter tuning in Cloud Machine Learning Engine using Bayesian Optimization.

5. Cliquez sur Continuer.

Configurer le calcul

Dans Options de calcul et tarifs, ne modifiez pas la région sélectionnée et sélectionnez Déployer vers un nouveau groupe de nœuds de calcul pour Paramètres de calcul.

Configurez le pool de nœuds de calcul 0 comme suit :

1. Pour Type de machine, sélectionnez Standard > n1-standard-4.
2. Pour Type de disque, sélectionnez SSD.
3. Pour Taille du disque (Go), saisissez 100.
4. Cliquez sur DÉMARRER L'ENTRAÎNEMENT pour lancer le job de réglage des hyperparamètres. Le contenu de l'onglet JOBS DE RÉGLAGE D'HYPERPARAMÈTRES de la section Entraînement de votre console ressemblera à ceci :

Remarque : Le job de réglage des hyperparamètres prendra approximativement de 55 à 60 minutes.

Quand il sera terminé, vous pourrez cliquer sur le nom du job et voir les résultats des essais de réglage.

Cliquez sur Vérifier ma progression pour valider l'objectif. Exécuter un job de réglage des hyperparamètres sur Vertex AI

Tâche 4 : Nettoyage

1. Si vous souhaitez continuer à utiliser le notebook que vous avez créé dans cet atelier, nous vous recommandons de le désactiver quand vous ne vous en servez pas. À partir de l'interface utilisateur de Notebooks dans la console Cloud, sélectionnez le notebook et cliquez sur Arrêter.

   Si vous souhaitez supprimer le notebook définitivement, il vous suffit de cliquer sur le bouton Supprimer situé en haut à droite.

2. Pour supprimer le bucket de stockage, accédez au menu de navigation > Cloud Storage, sélectionnez votre bucket et cliquez sur Supprimer.

Félicitations !

Vous savez désormais utiliser Vertex AI pour :

lancer un job de réglage des hyperparamètres pour le code d'entraînement fourni dans un conteneur personnalisé. Vous avez utilisé un modèle TensorFlow dans cet exemple, mais vous pouvez entraîner un modèle créé avec n'importe quel framework à l'aide de conteneurs personnalisés ou prédéfinis. Pour en savoir plus sur les différents composants de Vertex, consultez la documentation Vertex AI.

Terminer l'atelier

Une fois l'atelier terminé, cliquez sur End Lab (Terminer l'atelier). Qwiklabs supprime les ressources que vous avez utilisées, puis efface le compte.

Si vous le souhaitez, vous pouvez noter l'atelier. Sélectionnez le nombre d'étoiles correspondant à votre note, saisissez un commentaire, puis cliquez sur Submit (Envoyer).

Le nombre d'étoiles que vous pouvez attribuer à un atelier correspond à votre degré de satisfaction :

• 1 étoile = très mécontent(e)
• 2 étoiles = insatisfait(e)
• 3 étoiles = ni insatisfait(e), ni satisfait(e)
• 4 étoiles = satisfait(e)
• 5 étoiles = très satisfait(e)

Si vous ne souhaitez pas donner votre avis, vous pouvez fermer la boîte de dialogue.

Pour soumettre des commentaires, suggestions ou corrections, veuillez utiliser l'onglet Support (Assistance).

Copyright 2020 Google LLC Tous droits réservés. Google et le logo Google sont des marques de Google LLC. Tous les autres noms d'entreprises et de produits peuvent être des marques des entreprises auxquelles ils sont associés.