Présentation

Dans cet atelier, vous allez apprendre à utiliser Vertex AI pour entraîner et déployer un modèle TensorFlow, en exécutant du code dans un conteneur personnalisé.

Bien que cet atelier utilise TensorFlow pour le code du modèle, vous pourriez aisément le remplacer par un autre framework.

Objectifs de l'atelier

• Créer et conteneuriser le code d'entraînement du modèle dans un notebook Vertex AI
• Envoyer un job d'entraînement de modèle personnalisé à Vertex AI
• Déployer votre modèle entraîné sur un point de terminaison, et utiliser ce point de terminaison pour obtenir des prédictions

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 fait appel aux produits suivants : Training, Prediction et Notebooks.

Tâche 1 : Configurer votre environnement

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

Accédez à l'API Compute Engine et cliquez sur Activer si elle n'est pas déjà activée. Vous en aurez besoin pour créer votre instance Workbench.

Activer l'API Container Registry

Accédez à Container Registry et cliquez sur Activer si le service n'est pas déjà activé. Vous l'utiliserez afin de créer un conteneur pour votre job d'entraînement personnalisé.

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.

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

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

Vous allez envoyer ce job d'entraînement à Vertex AI. Pour ce faire, vous allez en premier lieu placer votre code d'entraînement dans un conteneur Docker, puis transmettre ce conteneur à Google Container Registry. Cette approche vous permet d'entraîner un modèle créé avec n'importe quel framework.

Pour commencer, accédez au menu de lancement et ouvrez une fenêtre de terminal dans votre instance Workbench.

Créez un répertoire nommé mpg et utilisez la commande cd pour y accéder :

mkdir mpg cd mpg

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 requises pour l'exécution de l'image. Ce fichier servira à installer toutes les bibliothèques requises et à configurer le point d'entrée de votre code d'entraînement. Depuis votre terminal, créez un Dockerfile vide :

touch Dockerfile

Ouvrez le fichier Dockerfile en accédant à mpg > Dockerfile, puis copiez-y le code suivant :

FROM gcr.io/deeplearning-platform-release/tf2-cpu.2-3 WORKDIR /root WORKDIR / # Copies the trainer code to the docker image. COPY trainer /trainer # Sets up the entry point to invoke the trainer. ENTRYPOINT ["python", "-m", "trainer.train"]

Ce Dockerfile utilise l'image Docker de TensorFlow Enterprise 2.3 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. Celui que vous allez utiliser inclut TF Enterprise 2.3, Pandas ou encore Scikit-learn. Une fois l'image téléchargée, ce Dockerfile configure le point d'entrée de votre code d'entraînement. Vous n'avez pas encore créé ces fichiers. À la prochaine étape, vous allez ajouter le code permettant d'entraîner et d'exporter votre modèle.

Créer un bucket Cloud Storage

Dans votre job d'entraînement, vous allez exporter le modèle TensorFlow entraîné vers un bucket Cloud Storage. Vertex utilisera ce bucket pour accéder en lecture aux ressources de votre modèle exporté ainsi que pour déployer le modèle. Depuis votre terminal, exécutez la commande suivante afin de définir une variable d'environnement pour votre projet. Veillez à 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'

Ensuite, exécutez la commande suivante dans votre terminal pour créer un bucket dans votre projet. L'option -l spécifie l'emplacement. Elle est importante, car l'emplacement doit être situé dans la même région que celle où vous allez déployer un point de terminaison du modèle dans la suite de ce tutoriel :

BUCKET_NAME="gs://${PROJECT_ID}-bucket" gsutil mb -l {{{ project_0.default_region | "REGION" }}} $BUCKET_NAME

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

Depuis votre terminal, exécutez les commandes suivantes 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/train.py

Votre répertoire "mpg/" devrait à présent contenir les éléments suivants :

+ Dockerfile + trainer/ + train.py

Ouvrez ensuite le fichier train.py que vous venez de créer en accédant à mpg > trainer > train.py, puis copiez-y le code ci-dessous (ce contenu a été adapté à partir du tutoriel disponible dans la documentation de TensorFlow).

Dans la première partie du fichier, remplacez la variable BUCKET par le nom du bucket Cloud Storage que vous avez créé à l'étape précédente :

import numpy as np import pandas as pd import pathlib import tensorflow as tf from tensorflow import keras from tensorflow.keras import layers print(tf.__version__) """## The Auto MPG dataset The dataset is available from the [UCI Machine Learning Repository](https://archive.ics.uci.edu/ml/). ### Get the data First download the dataset. """ dataset_path = keras.utils.get_file("auto-mpg.data", "http://archive.ics.uci.edu/ml/machine-learning-databases/auto-mpg/auto-mpg.data") dataset_path """Import it using pandas""" column_names = ['MPG','Cylinders','Displacement','Horsepower','Weight', 'Acceleration', 'Model Year', 'Origin'] dataset = pd.read_csv(dataset_path, names=column_names, na_values = "?", comment='\t', sep=" ", skipinitialspace=True) dataset.tail() # TODO: replace `your-gcs-bucket` with the name of the Storage bucket you created earlier BUCKET = 'gs://your-gcs-bucket' """### Clean the data The dataset contains a few unknown values. """ dataset.isna().sum() """To keep this initial tutorial simple, drop those rows.""" dataset = dataset.dropna() """The `"Origin"` column is really categorical, not numeric. So convert that to a one-hot:""" dataset['Origin'] = dataset['Origin'].map({1: 'USA', 2: 'Europe', 3: 'Japan'}) dataset = pd.get_dummies(dataset, prefix='', prefix_sep='') dataset.tail() """### Split the data into train and test Now split the dataset into a training set and a test set. You will use the test set in the final evaluation of your model. """ train_dataset = dataset.sample(frac=0.8,random_state=0) test_dataset = dataset.drop(train_dataset.index) """### Inspect the data Have a quick look at the joint distribution of a few pairs of columns from the training set. Also look at the overall statistics: """ train_stats = train_dataset.describe() train_stats.pop("MPG") train_stats = train_stats.transpose() train_stats """### Split features from labels Separate the target value, or "label", from the features. This label is the value that you will train the model to predict. """ train_labels = train_dataset.pop('MPG') test_labels = test_dataset.pop('MPG') """### Normalize the data Look again at the `train_stats` block above and note how different the ranges of each feature are. It is good practice to normalize features that use different scales and ranges. Although the model *might* converge without feature normalization, it makes training more difficult, and it makes the resulting model dependent on the choice of units used in the input. Note: Although we intentionally generate these statistics from only the training dataset, these statistics will also be used to normalize the test dataset. We need to do that to project the test dataset into the same distribution that the model has been trained on. """ def norm(x): return (x - train_stats['mean']) / train_stats['std'] normed_train_data = norm(train_dataset) normed_test_data = norm(test_dataset) """This normalized data is what we will use to train the model. Caution: The statistics used to normalize the inputs here (mean and standard deviation) need to be applied to any other data that is fed to the model, along with the one-hot encoding that we did earlier. That includes the test set as well as live data when the model is used in production. ## The model ### Build the model Let's build our model. Here, we'll use a `Sequential` model with two densely connected hidden layers, and an output layer that returns a single, continuous value. The model building steps are wrapped in a function, `build_model`, since we'll create a second model later on. """ def build_model(): model = keras.Sequential([ layers.Dense(64, activation='relu', input_shape=[len(train_dataset.keys())]), layers.Dense(64, activation='relu'), layers.Dense(1) ]) optimizer = tf.keras.optimizers.RMSprop(0.001) model.compile(loss='mse', optimizer=optimizer, metrics=['mae', 'mse']) return model model = build_model() """### Inspect the model Use the `.summary` method to print a simple description of the model """ model.summary() """Now try out the model. Take a batch of `10` examples from the training data and call `model.predict` on it. It seems to be working, and it produces a result of the expected shape and type. ### Train the model Train the model for 1000 epochs, and record the training and validation accuracy in the `history` object. Visualize the model's training progress using the stats stored in the `history` object. This graph shows little improvement, or even degradation, in the validation error after about 100 epochs. Let's update the `model.fit` call to automatically stop training when the validation score doesn't improve. We'll use an *EarlyStopping callback* that tests a training condition for every epoch. If a set amount of epochs elapses without showing improvement, then it will automatically stop the training. You can learn more about this callback [here](https://www.tensorflow.org/api_docs/python/tf/keras/callbacks/EarlyStopping). """ model = build_model() EPOCHS = 1000 # The patience parameter is the amount of epochs to check for improvement early_stop = keras.callbacks.EarlyStopping(monitor='val_loss', patience=10) early_history = model.fit(normed_train_data, train_labels, epochs=EPOCHS, validation_split = 0.2, callbacks=[early_stop]) # Export model and save to GCS model.save(BUCKET + '/mpg/model')

Créer et tester le conteneur localement

Depuis votre terminal, définissez une variable avec l'URI de votre image de conteneur dans Google Container Registry :

IMAGE_URI="gcr.io/$PROJECT_ID/mpg:v1"

Ensuite, créez le conteneur en exécutant la commande suivante à partir de la racine de votre répertoire mpg :

docker build ./ -t $IMAGE_URI

Exécutez le conteneur depuis votre instance Workbench pour vérifier qu'il fonctionne correctement :

docker run $IMAGE_URI

L'entraînement du modèle devrait prendre 1 à 2 minutes et la justesse de validation devrait avoisiner les 72 % (le taux de justesse peut varier légèrement). Après avoir exécuté le conteneur localement avec succès, transférez-le vers Google Container Registry :

docker push $IMAGE_URI

Maintenant que le conteneur a été transmis à Container Registry, vous pouvez démarrer un job d'entraînement de modèle personnalisé.

Tâche 3 : Exécuter un job d'entraînement sur Vertex AI

Avec Vertex AI, vous disposez de deux options pour entraîner des modèles :

• AutoML, qui vous permet d'entraîner facilement des modèles de grande qualité, quel que soit votre niveau d'expertise en ML
• L'entraînement personnalisé, qui vous permet d'exécuter vos applications d'entraînement personnalisé dans le cloud en vous servant de l'un des conteneurs préconfigurés de Google Cloud ou de votre propre conteneur

Dans cet atelier, vous allez utiliser l'entraînement personnalisé via notre propre conteneur personnalisé sur Google Container Registry. Pour commencer, accédez à Model Registry dans la section Vertex de la console Cloud :

Démarrer le job d'entraînement

Cliquez sur Créer pour saisir les paramètres du job d'entraînement et du modèle déployé :

• Pour Ensemble de données, sélectionnez Aucun ensemble de données géré.
• Sélectionnez ensuite Entraînement personnalisé (avancé) comme méthode d'entraînement, puis cliquez sur Continuer.
• Sélectionnez Entraîner le nouveau modèle, puis saisissez mpg (ou un autre nom de votre choix) dans le champ "Nom du modèle".
• Cliquez sur Continuer.

À l'étape Paramètres du conteneur, sélectionnez Conteneur personnalisé :

Dans le premier champ (Image de conteneur sur GCR), saisissez la valeur de la variable IMAGE_URI de la section précédente. Cette valeur doit ressembler à ceci : gcr.io/your-cloud-project/mpg:v1 (où "your-cloud-project" doit correspondre au nom de votre projet). Laissez les autres champs vides et cliquez sur Continuer.

Le réglage des hyperparamètres n'est pas utilisé dans cet atelier. Laissez la case Activer le réglage des hyperparamètres décochée et cliquez sur Continuer.

Dans Options de calcul et tarifs, sélectionnez la Région , puis Déployer vers un nouveau groupe de nœuds de calcul. Sélectionnez ensuite e2-standard-4 comme type de machine, puis cliquez sur Continuer.

Comme le modèle de cette démonstration peut être entraîné rapidement, vous pouvez utiliser un type de machine de plus petite taille.

Remarque : N'hésitez pas à tester des GPU et des types de machine plus volumineux si vous le souhaitez. Pour utiliser des GPU, vous devrez sélectionner une image de conteneur de base compatible avec les GPU.

À l'étape Conteneur de prédiction, choisissez Conteneur préconfiguré et sélectionnez 2.11 pour la Version du framework de modèle.

Conservez les paramètres par défaut du conteneur préconfiguré. Dans le champ Répertoire du modèle, recherchez votre bucket GCS (en ajoutant le sous-répertoire "mpg"). Il s'agit du chemin d'accès (inclus dans le script d'entraînement de modèle) de l'emplacement où vous exportez votre modèle entraîné. Il se présente comme ceci :

Vertex utilisera cet emplacement pendant le déploiement de votre modèle. Vous pouvez à présent cliquer sur Démarrer l'entraînement pour lancer le job d'entraînement. Dans la section Entraînement de votre console, sélectionnez pour Région. Vous verrez alors un écran semblable à celui-ci :

Remarque : Le job d'entraînement nécessitera environ 15 à 20 minutes.

Tâche 4 : Déployer un point de terminaison du modèle

Lorsque vous avez configuré votre job d'entraînement, vous avez spécifié l'emplacement dans lequel Vertex AI doit rechercher les ressources de votre modèle exporté. Dans notre pipeline d'entraînement, Vertex va créer une ressource de modèle basée sur ce chemin d'accès. Cette ressource de modèle n'est pas un modèle déployé en soi, mais une fois que vous avez un modèle, vous pouvez effectuer le déploiement sur un point de terminaison. Pour en savoir plus sur les modèles et les points de terminaison dans Vertex AI, consultez la documentation de présentation de Vertex AI.

Au cours de cette étape, vous allez créer un point de terminaison pour le modèle entraîné. Vous pouvez l'utiliser pour obtenir des prédictions à partir du modèle via l'API Vertex AI.

Déployer un point de terminaison

Une fois que votre job d'entraînement est terminé, un modèle nommé mpg (ou tout autre nom que vous avez préalablement spécifié) doit apparaître dans la section Model Registry de votre console :

Pendant l'exécution du job d'entraînement, Vertex a créé pour vous une ressource de modèle. Pour utiliser ce modèle, vous devez le déployer sur un point de terminaison. Un modèle peut avoir plusieurs points de terminaison. Cliquez sur le modèle, accédez à l'onglet Déployer et tester, puis sélectionnez Déployer sur un point de terminaison.

Sélectionnez Créer un point de terminaison et spécifiez un nom, par exemple v1. Cliquez ensuite sur Continuer. Laissez la Répartition du trafic réglée sur 100 et saisissez 1 dans le champ Nombre minimal de nœuds de calcul. Sous Type de machine, sélectionnez e2-standard-2 (ou tout autre type de machine que vous souhaitez utiliser). Cliquez ensuite sur OK, puis sur Déployer.

Le déploiement du point de terminaison prendra 10 à 15 minutes. Une fois le déploiement terminé, vous verrez apparaître le contenu suivant, qui montre un point de terminaison déployé pour votre ressource de modèle :

Remarque : La région du bucket et celle utilisée pour déployer le point de terminaison du modèle doivent être identiques.

Obtenir des prédictions à partir du modèle déployé

Vous pouvez obtenir des prédictions du modèle entraîné à partir d'un notebook Python, en utilisant l'API Vertex pour Python. Retournez dans votre instance Workbench et créez un notebook Python 3 à partir du menu de lancement :

Dans votre notebook, exécutez le code suivant dans une cellule pour installer le SDK Vertex AI :

!pip3 install google-cloud-aiplatform --upgrade --user

Ajoutez ensuite une cellule dans votre notebook pour importer le SDK et créer une référence au point de terminaison que vous venez de déployer :

from google.cloud import aiplatform endpoint = aiplatform.Endpoint( endpoint_name="projects/YOUR-PROJECT-NUMBER/locations/{{{ project_0.default_region | REGION }}}/endpoints/YOUR-ENDPOINT-ID" )

Vous devrez remplacer les deux valeurs (indiquées en majuscules) de la chaîne endpoint_name ci-dessus par votre numéro de projet et l'ID de votre point de terminaison. Le numéro de votre projet est indiqué dans le tableau de bord du projet.

Vous pouvez retrouver l'ID du point de terminaison dans la section "Points de terminaison" de la console :

Enfin, vous allez générer une prédiction sur votre point de terminaison en copiant et en exécutant le code ci-dessous dans une nouvelle cellule :

test_mpg = [1.4838871833555929, 1.8659883497083019, 2.234620276849616, 1.0187816540094903, -2.530890710602246, -1.6046416850441676, -0.4651483719733302, -0.4952254087173721, 0.7746763768735953] response = endpoint.predict([test_mpg]) print('API response: ', response) print('Predicted MPG: ', response.predictions[0][0])

Cet exemple présente déjà des valeurs normalisées, soit le format attendu par notre modèle.

Après avoir exécuté cette cellule, vous devriez obtenir un résultat de prédiction d'environ 16 mpg.

Tâche 5 : Nettoyage

1. Effectuez l'une des opérations suivantes :

   • Pour que vous puissiez 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.
   • Pour supprimer le notebook définitivement, cliquez sur Supprimer.

2. Pour supprimer le point de terminaison que vous avez déployé, sélectionnez la Région dans la liste déroulante de la section Prédiction en ligne de votre console Vertex AI, puis cliquez sur v1. Cliquez ensuite sur l'icône à trois points  à côté du point de terminaison, puis sélectionnez Annuler le déploiement du modèle sur le point de terminaison. Enfin, cliquez sur Annuler le déploiement.

3. Pour supprimer le point de terminaison, revenez à la section "Points de terminaison", cliquez sur l'icône Actions , puis sur Supprimer un point de terminaison.

4. Pour supprimer le bucket Cloud Storage, sélectionnez votre bucket sur la page Cloud Storage, puis cliquez sur Supprimer.

Félicitations !

Vous savez désormais utiliser Vertex AI pour effectuer les opérations suivantes :

• Entraîner un modèle en fournissant le code d'entraînement dans un conteneur personnalisé : dans cet exemple, vous avez utilisé un modèle TensorFlow, mais vous pouvez entraîner un modèle créé avec n'importe quel framework à l'aide de conteneurs personnalisés.
• Déployer un modèle TensorFlow à l'aide d'un conteneur préconfiguré dans le cadre du workflow que vous avez déjà utilisé pour l'entraînement
• Créer un point de terminaison de modèle et générer une prédiction

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.