GSP273

Présentation

Dans cet atelier, vous allez créer une instance Vertex AI Workbench sur laquelle vous développerez un modèle TensorFlow dans un notebook Jupyter. Vous entraînerez le modèle, créerez un pipeline de données d'entrée pour déployer ce modèle sur un point de terminaison, puis demanderez des prédictions.

TensorFlow est une plate-forme Open Source de bout en bout dédiée au machine learning. Cette plate-forme propose un écosystème complet et flexible d'outils, de bibliothèques et de ressources communautaires permettant aux chercheurs d'avancer dans le domaine du machine learning, et aux développeurs de créer et de déployer facilement des applications qui exploitent cette technologie.

Vertex AI rassemble AutoML et AI Platform au sein d'une API, d'une bibliothèque cliente et d'une interface utilisateur unifiées. Avec Vertex AI, l'entraînement AutoML et l'entraînement personnalisé sont tous deux disponibles.

Vertex AI Workbench permet aux utilisateurs de créer rapidement des workflows de bout en bout basés sur des notebooks, grâce à une intégration approfondie avec des services de données (Dataproc, Dataflow, BigQuery, Dataplex, etc.) et Vertex AI. Cette solution permet aux data scientists de se connecter aux services de données Google Cloud, d'analyser des ensembles de données, de tester différentes techniques de modélisation, de déployer des modèles entraînés en production et de gérer les MLOps tout au long du cycle de vie des modèles.

Vertex AI Workbench est un environnement de développement unique pour l'ensemble du workflow de science des données.

Cet atelier repose sur un ensemble d'exemples de code et de scripts développés pour l'ouvrage Data Science on Google Cloud Platform (2e édition) publié par O'Reilly Media, Inc.

Objectifs

• Déployer une instance Vertex AI Workbench
• Créer un minimum de données d'entraînement et de validation
• Créer le pipeline de données d'entrée
• Créer un modèle TensorFlow
• Déployer le modèle dans Vertex AI
• Déployer un modèle Explainable AI dans Vertex AI
• Obtenir des prédictions à partir du point de terminaison du modèle

Prérequis

Avant de cliquer sur le bouton "Démarrer l'atelier"

Lisez ces instructions. Les ateliers sont minutés, et vous ne pouvez pas les mettre en pause. Le minuteur, qui démarre lorsque vous cliquez sur Démarrer l'atelier, indique combien de temps les ressources Google Cloud resteront accessibles.

Cet atelier pratique vous permet de suivre vous-même les activités dans un véritable environnement cloud, et non dans un environnement de simulation ou de démonstration. Nous vous fournissons des identifiants temporaires pour vous connecter à Google Cloud le temps de l'atelier.

Pour réaliser cet atelier :

• vous devez avoir accès à un navigateur Internet standard (nous vous recommandons d'utiliser Chrome) ;

Remarque : Ouvrez une fenêtre de navigateur en mode incognito/navigation privée pour effectuer cet atelier. Vous éviterez ainsi les conflits entre votre compte personnel et le temporaire étudiant, qui pourraient entraîner des frais supplémentaires facturés sur votre compte personnel.

• vous disposez d'un temps limité ; une fois l'atelier commencé, vous ne pouvez pas le mettre en pause.

Remarque : Si vous possédez déjà votre propre compte ou projet Google Cloud, veillez à ne pas l'utiliser pour réaliser cet atelier afin d'éviter que des frais supplémentaires ne vous soient facturés.

Démarrer l'atelier et se connecter à la console Google Cloud

1. Cliquez sur le bouton Démarrer l'atelier. Si l'atelier est payant, un pop-up s'affiche pour vous permettre de sélectionner un mode de paiement. Sur la gauche, vous trouverez le panneau Détails concernant l'atelier, qui contient les éléments suivants :

   • Le bouton Ouvrir la console Google Cloud
   • Le temps restant
   • Les identifiants temporaires que vous devez utiliser pour cet atelier
   • Des informations complémentaires vous permettant d'effectuer l'atelier

2. Cliquez sur Ouvrir la console Google Cloud (ou effectuez un clic droit et sélectionnez Ouvrir le lien dans la fenêtre de navigation privée si vous utilisez le navigateur Chrome).

   L'atelier lance les ressources, puis ouvre la page Se connecter dans un nouvel onglet.

   Conseil : Réorganisez les onglets dans des fenêtres distinctes, placées côte à côte.

   Remarque : Si la boîte de dialogue Sélectionner un compte s'affiche, cliquez sur Utiliser un autre compte.

3. Si nécessaire, copiez le nom d'utilisateur ci-dessous et collez-le dans la boîte de dialogue Se connecter.

   {{{user_0.username | "Username"}}}

   Vous trouverez également le nom d'utilisateur dans le panneau Détails concernant l'atelier.

4. Cliquez sur Suivant.

5. Copiez le mot de passe ci-dessous et collez-le dans la boîte de dialogue Bienvenue.

   {{{user_0.password | "Password"}}}

   Vous trouverez également le mot de passe dans le panneau Détails concernant l'atelier.

6. Cliquez sur Suivant.

   Important : Vous devez utiliser les identifiants fournis pour l'atelier. Ne saisissez pas ceux de votre compte Google Cloud. Remarque : Si vous utilisez votre propre compte Google Cloud pour cet atelier, des frais supplémentaires peuvent vous être facturés.

7. Accédez aux pages suivantes :

   • Acceptez les conditions d'utilisation.
   • N'ajoutez pas d'options de récupération ni d'authentification à deux facteurs (ce compte est temporaire).
   • Ne vous inscrivez pas à des essais gratuits.

Après quelques instants, la console Cloud s'ouvre dans cet onglet.

Remarque : Pour afficher un menu contenant la liste des produits et services Google Cloud, cliquez sur le menu de navigation en haut à gauche.

Tâche 1 : Déployer une instance Vertex AI Workbench

1. Dans le menu de navigation de la console Google Cloud, cliquez sur Vertex AI > Workbench.

2. Cliquez sur + Créer.

3. Dans la boîte de dialogue Créer une instance, utilisez le nom par défaut ou saisissez un nom unique pour l'instance Vertex AI Workbench. Définissez la région sur et la zone sur , et laissez les autres paramètres par défaut.

4. Cliquez sur Créer.

5. Cliquez sur Ouvrir JupyterLab.

Pour utiliser un notebook, vous devez saisir des commandes dans une cellule. Veillez à lancer l'exécution des commandes depuis la cellule. Pour ce faire, appuyez sur Maj + Entrée ou cliquez sur l'icône triangulaire dans le menu supérieur du notebook afin d'exécuter les cellules sélectionnées et de passer à l'étape suivante.

Déployer une instance Vertex AI Workbench

Tâche 2 : Créer un minimum de données d'entraînement et de validation

1. Dans la section des lanceurs de Notebooks, cliquez sur Python 3 pour ouvrir un nouveau notebook.

2. Importez les bibliothèques Python et définissez des variables d'environnement :

import os, json, math, shutil import numpy as np import tensorflow as tf !sudo apt install graphviz -y # environment variables used by bash cells PROJECT=!(gcloud config get-value project) PROJECT=PROJECT[0] REGION = '{{{project_0.default_region}}}' BUCKET='{}-dsongcp'.format(PROJECT) os.environ['ENDPOINT_NAME'] = 'flights' os.environ['BUCKET'] = BUCKET os.environ['REGION'] = REGION os.environ['TF_VERSION']='2-' + tf.__version__[2:4] Remarque : Lorsque vous collez des commandes dans la cellule du notebook Jupyter, pensez à lancer l'exécution depuis la cellule pour vous assurer que la dernière commande de toute séquence est exécutée avant le passage à l'étape suivante.

Vous pouvez ignorer les avertissements TensorRT Library Load ou TensorFlow AVX2 FMA.

Exporter les fichiers contenant les données d'entraînement et de validation

Au début de cet atelier, quelques tables sont créées dans l'ensemble de données BigQuery. Dans cette section, vous allez créer des tables temporaires avec les données nécessaires dans BigQuery, puis exporter ces tables vers des fichiers CSV dans Google Cloud Storage. Ensuite, vous supprimerez ces tables temporaires. Pour poursuivre, vous allez lire et traiter ces fichiers de données CSV pour créer les ensembles de données d'entraînement et de validation, ainsi que l'ensemble de données complet dont vous avez besoin pour un modèle TensorFlow personnalisé.

1. Créez l'ensemble de données d'entraînement flights_train_data pour l'entraînement du modèle :

%%bigquery CREATE OR REPLACE TABLE dsongcp.flights_train_data AS SELECT IF(arr_delay < 15, 1.0, 0.0) AS ontime, dep_delay, taxi_out, distance, origin, dest, EXTRACT(hour FROM dep_time) AS dep_hour, IF (EXTRACT(dayofweek FROM dep_time) BETWEEN 2 AND 6, 1, 0) AS is_weekday, UNIQUE_CARRIER AS carrier, dep_airport_lat, dep_airport_lon, arr_airport_lat, arr_airport_lon FROM dsongcp.flights_tzcorr f JOIN dsongcp.trainday t ON f.FL_DATE = t.FL_DATE WHERE f.CANCELLED = False AND f.DIVERTED = False AND is_train_day = 'True'

2. Créez l'ensemble de données d'évaluation flights_eval_data pour l'évaluation du modèle :

%%bigquery CREATE OR REPLACE TABLE dsongcp.flights_eval_data AS SELECT IF(arr_delay < 15, 1.0, 0.0) AS ontime, dep_delay, taxi_out, distance, origin, dest, EXTRACT(hour FROM dep_time) AS dep_hour, IF (EXTRACT(dayofweek FROM dep_time) BETWEEN 2 AND 6, 1, 0) AS is_weekday, UNIQUE_CARRIER AS carrier, dep_airport_lat, dep_airport_lon, arr_airport_lat, arr_airport_lon FROM dsongcp.flights_tzcorr f JOIN dsongcp.trainday t ON f.FL_DATE = t.FL_DATE WHERE f.CANCELLED = False AND f.DIVERTED = False AND is_train_day = 'False'

3. Créez l'ensemble de données complet flights_all_data à l'aide du code suivant :

%%bigquery CREATE OR REPLACE TABLE dsongcp.flights_all_data AS SELECT IF(arr_delay < 15, 1.0, 0.0) AS ontime, dep_delay, taxi_out, distance, origin, dest, EXTRACT(hour FROM dep_time) AS dep_hour, IF (EXTRACT(dayofweek FROM dep_time) BETWEEN 2 AND 6, 1, 0) AS is_weekday, UNIQUE_CARRIER AS carrier, dep_airport_lat, dep_airport_lon, arr_airport_lat, arr_airport_lon, IF (is_train_day = 'True', IF(ABS(MOD(FARM_FINGERPRINT(CAST(f.FL_DATE AS STRING)), 100)) < 60, 'TRAIN', 'VALIDATE'), 'TEST') AS data_split FROM dsongcp.flights_tzcorr f JOIN dsongcp.trainday t ON f.FL_DATE = t.FL_DATE WHERE f.CANCELLED = False AND f.DIVERTED = False

4. Exportez tous les ensembles de données (entraînement, validation, complet) au format de fichier CSV dans le bucket Google Cloud Storage :

Cette opération prend environ deux minutes.

5. Patientez jusqu'à l'affichage du résultat de l'exécution du script bash suivant dans votre cellule de notebook :

%%bash PROJECT=$(gcloud config get-value project) for dataset in "train" "eval" "all"; do TABLE=dsongcp.flights_${dataset}_data CSV=gs://${BUCKET}/ch9/data/${dataset}.csv echo "Exporting ${TABLE} to ${CSV} and deleting table" bq --project_id=${PROJECT} extract --destination_format=CSV $TABLE $CSV bq --project_id=${PROJECT} rm -f $TABLE done

6. Listez les objets exportés vers le bucket Google Cloud Storage à l'aide du code suivant :

!gsutil ls -lh gs://{BUCKET}/ch9/data Créer les ensembles de données d'entraînement et de validation

Tâche 3 : Créer les données d'entrée

Configuration dans le notebook

1. À des fins de développement, vous effectuez l'entraînement pour un petit nombre d'époques. Cela explique pourquoi la valeur de NUM_EXAMPLES est si basse.

DEVELOP_MODE = True NUM_EXAMPLES = 5000*1000

2. Attribuez vos URI de données d'entraînement et de validation respectivement à training_data_uri et validation_data_uri :

training_data_uri = 'gs://{}/ch9/data/train*'.format(BUCKET) validation_data_uri = 'gs://{}/ch9/data/eval*'.format(BUCKET)

3. Définissez les paramètres du modèle à l'aide du bloc de code suivant :

NBUCKETS = 5 NEMBEDS = 3 TRAIN_BATCH_SIZE = 64 DNN_HIDDEN_UNITS = '64,32'

Lire les données dans TensorFlow

1. Pour lire les fichiers CSV de Google Cloud Storage dans TensorFlow, utilisez la méthode suivante du package tf.data :

if DEVELOP_MODE: train_df = tf.data.experimental.make_csv_dataset(training_data_uri, batch_size=5) for n, data in enumerate(train_df): numpy_data = {k: v.numpy() for k, v in data.items()} print(n, numpy_data) if n==1: break

Écrivez des fonctions features_and_labels() et read_dataset(). La fonction read_dataset() lit les données d'entraînement et génère des exemples batch_size à chaque lecture. En outre, elle permet d'arrêter l'itération une fois qu'un certain nombre d'exemples ont été lus.

L'ensemble de données contient toutes les colonnes du fichier CSV, nommées en fonction de la ligne d'en-tête. Les données comprennent à la fois les caractéristiques et les étiquettes. Il est conseillé de les séparer en écrivant la fonction features_and_labels() de manière à faciliter la lecture du code ultérieur. Par conséquent, une fonction pop() sera appliquée au dictionnaire et renverra un tuple de caractéristiques et d'étiquettes.

2. Saisissez et exécutez le code suivant :

def features_and_labels(features): label = features.pop('ontime') return features, label def read_dataset(pattern, batch_size, mode=tf.estimator.ModeKeys.TRAIN, truncate=None): dataset = tf.data.experimental.make_csv_dataset(pattern, batch_size, num_epochs=1) dataset = dataset.map(features_and_labels) if mode == tf.estimator.ModeKeys.TRAIN: dataset = dataset.shuffle(batch_size*10) dataset = dataset.repeat() dataset = dataset.prefetch(1) if truncate is not None: dataset = dataset.take(truncate) return dataset if DEVELOP_MODE: print("Checking input pipeline") one_item = read_dataset(training_data_uri, batch_size=2, truncate=1) print(list(one_item)) # should print one batch of 2 items

Tâche 4 : Créer, entraîner et évaluer le modèle TensorFlow

En règle générale, vous créez une caractéristique pour chaque colonne des données tabulaires. Les colonnes de caractéristiques sont disponibles dans Keras, ce qui permet de représenter des données structurées à l'aide de techniques d'extraction de caractéristiques standards telles que les représentations vectorielles continues, le binning et le croisement de caractéristiques. Étant donné que les données numériques peuvent être transmises directement au modèle de ML, vous devez séparer les colonnes à valeur réelle des colonnes creuses (ou de chaîne) :

1. Saisissez et exécutez le code suivant :

import tensorflow as tf real = { colname : tf.feature_column.numeric_column(colname) for colname in ( 'dep_delay,taxi_out,distance,dep_hour,is_weekday,' + 'dep_airport_lat,dep_airport_lon,' + 'arr_airport_lat,arr_airport_lon' ).split(',') } sparse = { 'carrier': tf.feature_column.categorical_column_with_vocabulary_list('carrier', vocabulary_list='AS,VX,F9,UA,US,WN,HA,EV,MQ,DL,OO,B6,NK,AA'.split(',')), 'origin' : tf.feature_column.categorical_column_with_hash_bucket('origin', hash_bucket_size=1000), 'dest' : tf.feature_column.categorical_column_with_hash_bucket('dest', hash_bucket_size=1000), }

Toutes ces caractéristiques proviennent directement du fichier d'entrée (et sont fournies par tout client qui demande une prédiction pour un vol). Les couches d'entrée présentent un mappage "1 pour 1" avec les caractéristiques d'entrée et leurs types. Par conséquent, plutôt que de répéter les noms de colonne, vous devez créer une couche d'entrée pour chacune de ces colonnes, en spécifiant le bon type de données (nombre à virgule flottante ou chaîne).

2. Saisissez et exécutez le code suivant :

inputs = { colname : tf.keras.layers.Input(name=colname, shape=(), dtype='float32') for colname in real.keys() } inputs.update({ colname : tf.keras.layers.Input(name=colname, shape=(), dtype='string') for colname in sparse.keys() })

Binning

Les colonnes à valeurs réelles dont la précision est excessive sont susceptibles de provoquer un surapprentissage. Elles peuvent être discrétisées et transformées en colonnes catégorielles. Par exemple, si vous disposez d'une colonne indiquant l'âge de l'avion, vous pouvez la discrétiser en seulement trois bins : moins de 5 ans, 5 à 20 ans et plus de 20 ans. Utilisez le raccourci de discrétisation. Vous pouvez discrétiser les latitudes et les longitudes et faire en sorte que les différents bins se croisent. Cela a pour effet de diviser le territoire en grilles et permet d'obtenir le point de grille dans lequel se situent une latitude et une longitude spécifiques.

• Saisissez et exécutez le code suivant :

latbuckets = np.linspace(20.0, 50.0, NBUCKETS).tolist() # USA lonbuckets = np.linspace(-120.0, -70.0, NBUCKETS).tolist() # USA disc = {} disc.update({ 'd_{}'.format(key) : tf.feature_column.bucketized_column(real[key], latbuckets) for key in ['dep_airport_lat', 'arr_airport_lat'] }) disc.update({ 'd_{}'.format(key) : tf.feature_column.bucketized_column(real[key], lonbuckets) for key in ['dep_airport_lon', 'arr_airport_lon'] }) # cross columns that make sense in combination sparse['dep_loc'] = tf.feature_column.crossed_column( [disc['d_dep_airport_lat'], disc['d_dep_airport_lon']], NBUCKETS*NBUCKETS) sparse['arr_loc'] = tf.feature_column.crossed_column( [disc['d_arr_airport_lat'], disc['d_arr_airport_lon']], NBUCKETS*NBUCKETS) sparse['dep_arr'] = tf.feature_column.crossed_column([sparse['dep_loc'], sparse['arr_loc']], NBUCKETS ** 4) # embed all the sparse columns embed = { 'embed_{}'.format(colname) : tf.feature_column.embedding_column(col, NEMBEDS) for colname, col in sparse.items() } real.update(embed) # one-hot encode the sparse columns sparse = { colname : tf.feature_column.indicator_column(col) for colname, col in sparse.items() } if DEVELOP_MODE: print(sparse.keys()) print(real.keys())

Entraîner et évaluer le modèle

1. Enregistrez le point de contrôle :

output_dir='gs://{}/ch9/trained_model'.format(BUCKET) os.environ['OUTDIR'] = output_dir # needed for deployment print('Writing trained model to {}'.format(output_dir))

2. Supprimez les points de contrôle du modèle déjà présents dans le bucket de stockage :

!gsutil -m rm -rf $OUTDIR

Vous recevez le message d'erreur CommandException: 1 files/objects could not be removed (Exception de commande : impossible de supprimer 1 fichier/objet), car le modèle n'a pas encore été enregistré. Cette erreur signale que l'emplacement cible ne comporte aucun fichier. Vous devez vous assurer que cet emplacement est vide avant d'essayer d'enregistrer le modèle. C'est précisément ce que cette commande vous permet de faire.

3. Grâce aux colonnes de caractéristiques creuses et à valeur réelle ainsi améliorées au-delà des entrées brutes, vous pouvez créer un classificateur large et profond (wide_and_deep_classifier) en transmettant séparément les colonnes de caractéristiques linéaires et profondes :

# Build a wide-and-deep model. def wide_and_deep_classifier(inputs, linear_feature_columns, dnn_feature_columns, dnn_hidden_units): deep = tf.keras.layers.DenseFeatures(dnn_feature_columns, name='deep_inputs')(inputs) layers = [int(x) for x in dnn_hidden_units.split(',')] for layerno, numnodes in enumerate(layers): deep = tf.keras.layers.Dense(numnodes, activation='relu', name='dnn_{}'.format(layerno+1))(deep) wide = tf.keras.layers.DenseFeatures(linear_feature_columns, name='wide_inputs')(inputs) both = tf.keras.layers.concatenate([deep, wide], name='both') output = tf.keras.layers.Dense(1, activation='sigmoid', name='pred')(both) model = tf.keras.Model(inputs, output) model.compile(optimizer='adam', loss='binary_crossentropy', metrics=['accuracy']) return model model = wide_and_deep_classifier( inputs, linear_feature_columns = sparse.values(), dnn_feature_columns = real.values(), dnn_hidden_units = DNN_HIDDEN_UNITS) tf.keras.utils.plot_model(model, 'flights_model.png', show_shapes=False, rankdir='LR')

Utilisez train_dataset pour l'entraînement du modèle et eval_dataset pour l'évaluation du modèle.

4. Créez le modèle à l'aide des blocs de code suivants :

# training and evaluation dataset train_batch_size = TRAIN_BATCH_SIZE if DEVELOP_MODE: eval_batch_size = 100 steps_per_epoch = 3 epochs = 2 num_eval_examples = eval_batch_size*10 else: eval_batch_size = 100 steps_per_epoch = NUM_EXAMPLES // train_batch_size epochs = 10 num_eval_examples = eval_batch_size * 100 train_dataset = read_dataset(training_data_uri, train_batch_size) eval_dataset = read_dataset(validation_data_uri, eval_batch_size, tf.estimator.ModeKeys.EVAL, num_eval_examples) checkpoint_path = '{}/checkpoints/flights.cpt'.format(output_dir) shutil.rmtree(checkpoint_path, ignore_errors=True) cp_callback = tf.keras.callbacks.ModelCheckpoint(checkpoint_path, save_weights_only=True, verbose=1) history = model.fit(train_dataset, validation_data=eval_dataset, epochs=epochs, steps_per_epoch=steps_per_epoch, callbacks=[cp_callback])

5. Visualisez la perte et la justesse du modèle à l'aide de matplotlib.pyplot :

import matplotlib.pyplot as plt nrows = 1 ncols = 2 fig = plt.figure(figsize=(10, 5)) for idx, key in enumerate(['loss', 'accuracy']): ax = fig.add_subplot(nrows, ncols, idx+1) plt.plot(history.history[key]) plt.plot(history.history['val_{}'.format(key)]) plt.title('model {}'.format(key)) plt.ylabel(key) plt.xlabel('epoch') plt.legend(['train', 'validation'], loc='upper left');

Le résultat ressemble à ceci :

Remarque : La perte liée à l'entraînement et le graphique de précision du modèle peuvent ne pas correspondre, car vous effectuez l'entraînement sur un échantillon aléatoire de très petite taille.

Exporter le modèle entraîné

• Enregistrez les artefacts du modèle dans le bucket Google Cloud Storage :

import time export_dir = '{}/export/flights_{}'.format(output_dir, time.strftime("%Y%m%d-%H%M%S")) print('Exporting to {}'.format(export_dir)) tf.saved_model.save(model, export_dir) Créer le modèle TensorFlow

Tâche 5 : Déployer le modèle "flights" dans Vertex AI

Vertex AI offre un environnement entièrement géré, sans serveur et avec autoscaling pour les modèles de machine learning. Vous bénéficiez des avantages du paiement à l'usage pour toutes les ressources de calcul (telles que les CPU ou les GPU). La gestion des dépendances est prise en charge, car les modèles sont conteneurisés. Les points de terminaison assurent la répartition du trafic, ce qui vous permet d'effectuer facilement des tests A/B.

Les avantages vont au-delà de l'absence de gestion d'infrastructure. Après avoir déployé un modèle dans Vertex AI, vous accédez à de nombreuses fonctionnalités intéressantes sans avoir à ajouter de code supplémentaire : explicabilité, détection des dérives, surveillance, etc.

1. Avec la cellule de code suivante, créez le point de terminaison du modèle flights et supprimez tous les modèles existants ayant le même nom :

%%bash # note TF_VERSION and ENDPOINT_NAME set in 1st cell # TF_VERSION=2-6 # ENDPOINT_NAME=flights TIMESTAMP=$(date +%Y%m%d-%H%M%S) MODEL_NAME=${ENDPOINT_NAME}-${TIMESTAMP} EXPORT_PATH=$(gsutil ls ${OUTDIR}/export | tail -1) echo $EXPORT_PATH # create the model endpoint for deploying the model if [[ $(gcloud beta ai endpoints list --region=$REGION \ --format='value(DISPLAY_NAME)' --filter=display_name=${ENDPOINT_NAME}) ]]; then echo "Endpoint for $MODEL_NAME already exists" else echo "Creating Endpoint for $MODEL_NAME" gcloud beta ai endpoints create --region=${REGION} --display-name=${ENDPOINT_NAME} fi ENDPOINT_ID=$(gcloud beta ai endpoints list --region=$REGION \ --format='value(ENDPOINT_ID)' --filter=display_name=${ENDPOINT_NAME}) echo "ENDPOINT_ID=$ENDPOINT_ID" # delete any existing models with this name for MODEL_ID in $(gcloud beta ai models list --region=$REGION --format='value(MODEL_ID)' --filter=display_name=${MODEL_NAME}); do echo "Deleting existing $MODEL_NAME ... $MODEL_ID " gcloud ai models delete --region=$REGION $MODEL_ID done # create the model using the parameters docker conatiner image and artifact uri gcloud beta ai models upload --region=$REGION --display-name=$MODEL_NAME \ --container-image-uri=us-docker.pkg.dev/vertex-ai/prediction/tf2-cpu.${TF_VERSION}:latest \ --artifact-uri=$EXPORT_PATH MODEL_ID=$(gcloud beta ai models list --region=$REGION --format='value(MODEL_ID)' --filter=display_name=${MODEL_NAME}) echo "MODEL_ID=$MODEL_ID" # deploy the model to the endpoint gcloud beta ai endpoints deploy-model $ENDPOINT_ID \ --region=$REGION \ --model=$MODEL_ID \ --display-name=$MODEL_NAME \ --machine-type=e2-standard-2 \ --min-replica-count=1 \ --max-replica-count=1 \ --traffic-split=0=100 Remarque : Une erreur peut parfois se produire environ cinq minutes après le début de ce processus. Si vous rencontrez une erreur lors de la création du modèle, telle que "The service account doesn't have sufficient permissions for writing objects to the Google Cloud Storage bucket" (Le compte de service ne dispose pas des autorisations nécessaires pour écrire des objets dans le bucket Google Cloud Storage), essayez d'exécuter à nouveau la cellule de code. Par ailleurs, activez l'API Vertex AI si cela n'est pas déjà fait. Remarque : La création du modèle et de son point de terminaison, puis le déploiement du modèle sur ce point de terminaison prennent de 15 à 20 minutes. Si vous ne parvenez pas à accéder au lien du point de terminaison généré, veuillez l'ignorer. Pour afficher la progression dans la console Cloud, cliquez sur Menu de navigation > Vertex AI > Prédiction en ligne > Points de terminaison. Déployer le modèle "flights" dans Vertex AI

2. Créez un fichier d'entrée example_input.json de test à l'aide du code suivant :

%%writefile example_input.json {"instances": [ {"dep_hour": 2, "is_weekday": 1, "dep_delay": 40, "taxi_out": 17, "distance": 41, "carrier": "AS", "dep_airport_lat": 58.42527778, "dep_airport_lon": -135.7075, "arr_airport_lat": 58.35472222, "arr_airport_lon": -134.57472222, "origin": "GST", "dest": "JNU"}, {"dep_hour": 22, "is_weekday": 0, "dep_delay": -7, "taxi_out": 7, "distance": 201, "carrier": "HA", "dep_airport_lat": 21.97611111, "dep_airport_lon": -159.33888889, "arr_airport_lat": 20.89861111, "arr_airport_lon": -156.43055556, "origin": "LIH", "dest": "OGG"} ]}

3. Effectuez une requête de prédiction depuis le point de terminaison du modèle. Voici les données d'entrée présentées dans un fichier au format JSON appelé example_input.json :

%%bash ENDPOINT_ID=$(gcloud beta ai endpoints list --region=$REGION \ --format='value(ENDPOINT_ID)' --filter=display_name=${ENDPOINT_NAME}) echo $ENDPOINT_ID gcloud beta ai endpoints predict $ENDPOINT_ID --region=$REGION --json-request=example_input.json

Les programmes clients peuvent utiliser cette méthode pour appeler le modèle que vous avez déployé.

Supposons que ces programmes ont accès aux données d'entrée dans un fichier au format JSON appelé example_input.json.

4. Envoyez une requête HTTP POST pour obtenir le résultat au format JSON :

%%bash PROJECT=$(gcloud config get-value project) ENDPOINT_ID=$(gcloud beta ai endpoints list --region=$REGION \ --format='value(ENDPOINT_ID)' --filter=display_name=${ENDPOINT_NAME}) curl -X POST \ -H "Authorization: Bearer "$(gcloud auth application-default print-access-token) \ -H "Content-Type: application/json; charset=utf-8" \ -d @example_input.json \ "https://${REGION}-aiplatform.googleapis.com/v1/projects/${PROJECT}/locations/${REGION}/endpoints/${ENDPOINT_ID}:predict"

Tâche 6 : Explicabilité

L'explicabilité des modèles est l'un des principaux problèmes du machine learning. Ce concept large englobe l'analyse et la compréhension des résultats fournis par les modèles de machine learning. L'explicabilité en machine learning signifie que vous pouvez expliquer ce qui se passe dans votre modèle, de l'entrée à la sortie. Cette approche résout le problème d'opacité des modèles en les rendant plus transparents. Explainable AI (XAI) est la méthode la plus formelle pour décrire cela.

1. Exécutez le code suivant :

%%bash model_dir=$(gsutil ls ${OUTDIR}/export | tail -1) echo $model_dir saved_model_cli show --tag_set serve --signature_def serving_default --dir $model_dir

2. Créez un fichier au format JSON appelé explanation-metadata.json avec les métadonnées qui décrivent l'entrée et la sortie du modèle à des fins explicatives. Dans cet exemple, vous allez utiliser la méthode sampled-shapley pour expliquer le modèle :

cols = ('dep_delay,taxi_out,distance,dep_hour,is_weekday,' + 'dep_airport_lat,dep_airport_lon,' + 'arr_airport_lat,arr_airport_lon,' + 'carrier,origin,dest') inputs = {x: {"inputTensorName": "{}".format(x)} for x in cols.split(',')} expl = { "inputs": inputs, "outputs": { "pred": { "outputTensorName": "pred" } } } print(expl) with open('explanation-metadata.json', 'w') as ofp: json.dump(expl, ofp, indent=2)

3. Affichez le fichier explanation-metadata.json à l'aide de la commande cat :

!cat explanation-metadata.json

Créer et déployer un autre modèle flight_xai dans Vertex AI

• Créez le point de terminaison du modèle flights_xai, puis importez le modèle et déployez-le sur son point de terminaison à l'aide du code suivant :

%%bash # note ENDPOINT_NAME is being changed ENDPOINT_NAME=flights_xai TIMESTAMP=$(date +%Y%m%d-%H%M%S) MODEL_NAME=${ENDPOINT_NAME}-${TIMESTAMP} EXPORT_PATH=$(gsutil ls ${OUTDIR}/export | tail -1) echo $EXPORT_PATH # create the model endpoint for deploying the model if [[ $(gcloud beta ai endpoints list --region=$REGION \ --format='value(DISPLAY_NAME)' --filter=display_name=${ENDPOINT_NAME}) ]]; then echo "Endpoint for $MODEL_NAME already exists" else # create model endpoint echo "Creating Endpoint for $MODEL_NAME" gcloud beta ai endpoints create --region=${REGION} --display-name=${ENDPOINT_NAME} fi ENDPOINT_ID=$(gcloud beta ai endpoints list --region=$REGION \ --format='value(ENDPOINT_ID)' --filter=display_name=${ENDPOINT_NAME}) echo "ENDPOINT_ID=$ENDPOINT_ID" # delete any existing models with this name for MODEL_ID in $(gcloud beta ai models list --region=$REGION --format='value(MODEL_ID)' --filter=display_name=${MODEL_NAME}); do echo "Deleting existing $MODEL_NAME ... $MODEL_ID " gcloud ai models delete --region=$REGION $MODEL_ID done # upload the model using the parameters docker conatiner image, artifact URI, explanation method, # explanation path count and explanation metadata JSON file `explanation-metadata.json`. # Here, you keep number of feature permutations to `10` when approximating the Shapley values for explanation. gcloud beta ai models upload --region=$REGION --display-name=$MODEL_NAME \ --container-image-uri=us-docker.pkg.dev/vertex-ai/prediction/tf2-cpu.${TF_VERSION}:latest \ --artifact-uri=$EXPORT_PATH \ --explanation-method=sampled-shapley --explanation-path-count=10 --explanation-metadata-file=explanation-metadata.json MODEL_ID=$(gcloud beta ai models list --region=$REGION --format='value(MODEL_ID)' --filter=display_name=${MODEL_NAME}) echo "MODEL_ID=$MODEL_ID" # deploy the model to the endpoint gcloud beta ai endpoints deploy-model $ENDPOINT_ID \ --region=$REGION \ --model=$MODEL_ID \ --display-name=$MODEL_NAME \ --machine-type=e2-standard-2 \ --min-replica-count=1 \ --max-replica-count=1 \ --traffic-split=0=100 Remarque : La création du modèle et de son point de terminaison, puis le déploiement du modèle sur ce point de terminaison prennent de 15 à 20 minutes. Si vous ne parvenez pas à accéder au lien du point de terminaison généré, veuillez l'ignorer. Pour afficher la progression dans la console Cloud, cliquez sur Menu de navigation > Vertex AI > Prédiction en ligne > Points de terminaison. Déployer le modèle "flights_xai" dans Vertex AI

Tâche 7 : Appeler le modèle déployé

Les programmes clients peuvent utiliser cette méthode pour appeler le modèle que vous avez déployé. Supposons que ces programmes ont accès aux données d'entrée dans un fichier au format JSON appelé example_input.json. Envoyez une requête HTTP POST pour obtenir le résultat au format JSON.

• Exécutez le code suivant :

%%bash PROJECT=$(gcloud config get-value project) ENDPOINT_NAME=flights_xai ENDPOINT_ID=$(gcloud beta ai endpoints list --region=$REGION \ --format='value(ENDPOINT_ID)' --filter=display_name=${ENDPOINT_NAME}) curl -X POST \ -H "Authorization: Bearer "$(gcloud auth application-default print-access-token) \ -H "Content-Type: application/json; charset=utf-8" \ -d @example_input.json \ "https://${REGION}-aiplatform.googleapis.com/v1/projects/${PROJECT}/locations/${REGION}/endpoints/${ENDPOINT_ID}:explain"

Félicitations !

Félicitations ! Dans cet atelier, vous avez appris à créer un modèle avec Vertex AI et à le déployer sur des points de terminaison Vertex AI. Vous avez également appris à expliquer les prédictions du modèle à l'aide de la fonctionnalité Vertex AI Explainable AI (XAI). Vous avez ensuite entraîné un modèle de régression logistique sur l'ensemble des valeurs d'entrée, et vous avez découvert que le modèle n'était pas en mesure d'exploiter efficacement les nouvelles caractéristiques, telles que l'emplacement des aéroports.

Étapes suivantes et informations supplémentaires

• Data Science on the Google Cloud Platform (2e édition), publié par O'Reilly Media, Inc.

Formations et certifications Google Cloud

Les formations et certifications Google Cloud vous aident à tirer pleinement parti des technologies Google Cloud. Nos cours portent sur les compétences techniques et les bonnes pratiques à suivre pour être rapidement opérationnel et poursuivre votre apprentissage. Nous proposons des formations pour tous les niveaux, à la demande, en salle et à distance, pour nous adapter aux emplois du temps de chacun. Les certifications vous permettent de valider et de démontrer vos compétences et votre expérience en matière de technologies Google Cloud.

Dernière modification du manuel : 30 octobre 2023

Dernier test de l'atelier : 31 octobre 2023

Copyright 2024 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.