1. Présentation
Dans cet atelier, vous allez apprendre à exécuter un job d'entraînement de modèle personnalisé à l'aide du SDK Kubeflow Pipelines sur Vertex Pipelines.
Objectifs
Vous allez apprendre à effectuer les opérations suivantes :
- Utiliser le SDK Kubeflow Pipelines pour créer des pipelines de ML évolutifs
- Créer et conteneuriser un job d'entraînement de modèle Scikit-learn personnalisé qui utilise des ensembles de données gérés Vertex AI et qui s'exécutera sur Vertex AI Training dans un pipeline
- Exécuter un job de prédiction par lot dans Vertex Pipelines
- Utiliser des composants prédéfinis pour interagir avec les services Vertex AI, fournis via la bibliothèque
google_cloud_pipeline_components
Le coût total d'exécution de cet atelier sur Google Cloud est d'environ 5$.
2. Présentation de Vertex AI
Cet atelier utilise Vertex AI, notre plate-forme de ML gérée de bout en bout sur Google Cloud. Vertex AI intègre toutes les offres de ML de Google Cloud pour créer une expérience de développement simple. Outre les services d'entraînement et de déploiement de modèles, Vertex AI inclut également divers produits MLOps comme Vertex Pipelines (sur lequel porte cet atelier), Model Monitoring, Feature Store, etc. Toutes les offres de produits de Vertex AI sont répertoriées dans le schéma ci-dessous.
Pour envoyer un commentaire, veuillez consulter la page d'assistance.
Pourquoi utiliser des pipelines de ML ?
Avant d'entrer dans le vif du sujet, vous devez comprendre les avantages d'un pipeline. Imaginez que vous créez un workflow de ML incluant le traitement de données, l'entraînement d'un modèle, le réglage d'hyperparamètres, l'évaluation et le déploiement d'un modèle. Chacune de ces étapes peut avoir des dépendances différentes, ce qui peut se révéler problématique si vous traitez l'ensemble du workflow comme un monolithe. Lorsque vous commencerez le scaling de votre processus de ML, vous souhaiterez peut-être partager votre workflow de ML avec le reste de votre équipe, afin qu'elle puisse l'exécuter et participer à l'écriture du code. Cela peut s'avérer difficile sans un processus fiable et reproductible. Avec les pipelines, chaque étape de votre processus de ML est son propre conteneur. Ainsi, vous pouvez développer des étapes de façon indépendante et suivre les entrées et sorties de chaque étape de manière reproductible. Vous pouvez également planifier ou déclencher des exécutions de votre pipeline en fonction d'autres événements dans votre environnement cloud. Par exemple, vous pouvez exécuter un pipeline lorsque de nouvelles données d'entraînement sont disponibles.
En résumé : les pipelines vous aident à rationaliser et reproduire vos workflows de ML.
3. Configurer l'environnement cloud
Pour suivre cet atelier de programmation, vous aurez besoin d'un projet Google Cloud Platform dans lequel la facturation est activée. Pour créer un projet, suivez ces instructions.
Étape 1 : Démarrer Cloud Shell
Dans cet atelier, vous allez travailler dans une session Cloud Shell. Cet environnement est un interpréteur de commandes hébergé sur une machine virtuelle qui s'exécute dans le cloud de Google. Vous pourriez tout aussi facilement effectuer les tâches de cette section en local sur votre propre ordinateur, mais le fait d'utiliser Cloud Shell permet à chacun de bénéficier d'une expérience reproductible dans un environnement cohérent. Après l'atelier, libre à vous de reproduire cette section sur votre ordinateur.
Activer Cloud Shell
En haut à droite de la console Cloud, cliquez sur le bouton Activer Cloud Shell :
Si vous n'avez jamais démarré Cloud Shell auparavant, un écran intermédiaire s'affiche en dessous de la ligne de flottaison, décrivant de quoi il s'agit. Si tel est le cas, cliquez sur Continuer. Cet écran ne s'affiche qu'une seule fois. Voici à quoi il ressemble :
Le provisionnement et la connexion à Cloud Shell ne devraient pas prendre plus de quelques minutes.
Cette machine virtuelle contient tous les outils de développement dont vous avez besoin. Elle comprend un répertoire d'accueil persistant de 5 Go et s'exécute sur Google Cloud, ce qui améliore nettement les performances du réseau et l'authentification. Vous pouvez réaliser une grande partie, voire la totalité, des activités de cet atelier dans un simple navigateur ou sur votre Chromebook.
Une fois connecté à Cloud Shell, vous êtes en principe authentifié et le projet est défini avec votre ID de projet.
Exécutez la commande suivante dans Cloud Shell pour vérifier que vous êtes authentifié :
gcloud auth list
Le résultat de la commande doit ressembler à ceci :
Exécutez la commande suivante dans Cloud Shell pour vérifier que la commande gcloud connaît votre projet :
gcloud config list project
Résultat de la commande
[core] project = <PROJECT_ID>
Si vous obtenez un résultat différent, exécutez cette commande :
gcloud config set project <PROJECT_ID>
Résultat de la commande
Updated property [core/project].
Cloud Shell comporte quelques variables d'environnement, dont GOOGLE_CLOUD_PROJECT, qui contient le nom de notre projet Cloud actuel. Nous l'utiliserons à plusieurs endroits tout au long de cet atelier. Pour la voir, exécutez la commande suivante :
echo $GOOGLE_CLOUD_PROJECT
Étape 2 : Activez les API
Dans les étapes suivantes, vous verrez où ces services sont requis (et pourquoi). Mais pour l'instant, exécutez la commande ci-dessous pour autoriser votre projet à accéder aux services Compute Engine, Container Registry et Vertex AI :
gcloud services enable compute.googleapis.com \
containerregistry.googleapis.com \
aiplatform.googleapis.com
Un message semblable à celui qui suit s'affiche pour vous indiquer que l'opération s'est correctement déroulée :
Operation "operations/acf.cc11852d-40af-47ad-9d59-477a12847c9e" finished successfully.
Étape 3 : Créer un bucket Cloud Storage
Pour exécuter un job d'entraînement sur Vertex AI, nous avons besoin d'un bucket de stockage dans lequel enregistrer les ressources de modèle. Ce bucket doit être régional. Nous utilisons ici us-central, mais vous pouvez utiliser une autre région (il vous suffit d'effectuer le remplacement tout au long de cet atelier). Si vous disposez déjà d'un bucket, vous pouvez ignorer cette étape.
Exécutez les commandes suivantes dans votre terminal Cloud Shell afin de créer un bucket :
BUCKET_NAME=gs://$GOOGLE_CLOUD_PROJECT-bucket
gsutil mb -l us-central1 $BUCKET_NAME
Nous allons ensuite autoriser notre compte de service Compute à accéder à ce bucket. Ainsi, Vertex Pipelines disposera des autorisations nécessaires pour écrire des fichiers dans ce bucket. Exécutez la commande suivante pour ajouter cette autorisation :
gcloud projects describe $GOOGLE_CLOUD_PROJECT > project-info.txt
PROJECT_NUM=$(cat project-info.txt | sed -nre 's:.*projectNumber\: (.*):\1:p')
SVC_ACCOUNT="${PROJECT_NUM//\'/}-compute@developer.gserviceaccount.com"
gcloud projects add-iam-policy-binding $GOOGLE_CLOUD_PROJECT --member serviceAccount:$SVC_ACCOUNT --role roles/storage.objectAdmin
Étape 4 : Créez une instance Vertex AI Workbench
Dans la section Vertex AI de Cloud Console, cliquez sur Workbench :
Dans Notebooks gérés par l'utilisateur, cliquez sur Nouveau notebook :
Sélectionnez ensuite le type d'instance TensorFlow Enterprise 2.3 (avec LTS) sans GPU :
Utilisez les options par défaut, puis cliquez sur Créer.
Étape 5 : Ouvrez votre notebook
Une fois l'instance créée, sélectionnez Ouvrir JupyterLab :
4. Configuration de Vertex Pipelines
Pour utiliser Vertex Pipelines, il est nécessaire d'installer quelques bibliothèques supplémentaires.
- Kubeflow Pipelines : le SDK que nous utiliserons pour créer notre pipeline. Vertex Pipelines est compatible avec l'exécution de pipelines créés avec Kubeflow Pipelines ou TFX.
- Google Cloud Pipeline Components : cette bibliothèque fournit des composants prédéfinis qui permettent d'interagir plus facilement avec les services Vertex AI à partir de vos étapes de pipeline.
Étape 1 : Créez un notebook Python et installez les bibliothèques
Tout d'abord, dans le menu de lancement de votre instance de notebook (accessible en cliquant sur l'icône + en haut à gauche de votre notebook), créez un notebook en sélectionnant Python 3 :
Pour accéder au menu de lancement, cliquez sur le signe + en haut à gauche de votre instance de notebook.
Pour installer les deux services que nous utiliserons dans cet atelier, vous devez d'abord définir l'option utilisateur dans une cellule du notebook :
USER_FLAG = "--user"
Exécutez ensuite les commandes suivantes depuis votre notebook :
!pip3 install {USER_FLAG} google-cloud-aiplatform==1.7.0 --upgrade
!pip3 install {USER_FLAG} kfp==1.8.9 google-cloud-pipeline-components==0.2.0
Une fois ces packages installés, vous devrez redémarrer le kernel :
import os
if not os.getenv("IS_TESTING"):
# Automatically restart kernel after installs
import IPython
app = IPython.Application.instance()
app.kernel.do_shutdown(True)
Pour finir, vérifiez que vous avez correctement installé les packages. Utilisez la version 1.8 du SDK KFP ou une version ultérieure :
!python3 -c "import kfp; print('KFP SDK version: {}'.format(kfp.__version__))"
!python3 -c "import google_cloud_pipeline_components; print('google_cloud_pipeline_components version: {}'.format(google_cloud_pipeline_components.__version__))"
Étape 2 : Définissez l'ID et le bucket de votre projet
Au cours de cet atelier, vous allez référencer votre ID de projet Cloud et le bucket que vous avez créé un peu plus tôt. Nous allons à présent créer des variables pour chacun d'eux.
Si vous ne connaissez pas votre ID de projet, vous pouvez l'obtenir en exécutant la commande suivante :
import os
PROJECT_ID = ""
# Get your Google Cloud project ID from gcloud
if not os.getenv("IS_TESTING"):
shell_output=!gcloud config list --format 'value(core.project)' 2>/dev/null
PROJECT_ID = shell_output[0]
print("Project ID: ", PROJECT_ID)
Sinon, définissez-le ici :
if PROJECT_ID == "" or PROJECT_ID is None:
PROJECT_ID = "your-project-id" # @param {type:"string"}
Ensuite, créez une variable pour stocker le nom de votre bucket. Si vous l'avez créée au cours de cet atelier, les étapes suivantes devraient fonctionner. Sinon, vous devrez la définir manuellement :
BUCKET_NAME="gs://" + PROJECT_ID + "-bucket"
Étape 3 : Importez les bibliothèques
Ajoutez le code suivant pour importer les bibliothèques que nous utiliserons dans cet atelier de programmation :
from kfp.v2 import compiler, dsl
from kfp.v2.dsl import pipeline
from google.cloud import aiplatform
from google_cloud_pipeline_components import aiplatform as gcc_aip
Étape 4 : Définissez les constantes
La dernière chose que nous devons faire avant de pouvoir créer notre pipeline est de définir des variables constantes. PIPELINE_ROOT est le chemin d'accès Cloud Storage dans lequel les artefacts créés par notre pipeline seront écrits. Ici, nous utilisons us-central1 comme région, mais si vous avez choisi une autre région lorsque vous avez créé votre bucket, modifiez la variable REGION dans le code ci-dessous :
PATH=%env PATH
%env PATH={PATH}:/home/jupyter/.local/bin
REGION="us-central1"
PIPELINE_ROOT = f"{BUCKET_NAME}/pipeline_root/"
PIPELINE_ROOT
Une fois le code ci-dessus exécuté, le répertoire racine de votre pipeline doit s'afficher. Il s'agit de l'emplacement Cloud Storage dans lequel les artefacts de votre pipeline seront écrits. Elle se présentera au format gs://YOUR-BUCKET-NAME/pipeline_root/.
5. Configurer un job d'entraînement de modèle personnalisé
Avant de configurer notre pipeline, nous devons écrire le code de notre job d'entraînement de modèle personnalisé. Pour entraîner le modèle, nous utiliserons l'ensemble de données UCI Machine Learning Dry beans dataset de KOKLU, M. et OZKAN, I.A., (2020), "Multiclass Classification of Dry Beans Using Computer Vision and Machine Learning Techniques." publié dans "Computers and Electronics in Agriculture", 174, 105507. DOI.
La première étape de notre pipeline consiste à créer un ensemble de données géré dans Vertex AI à l'aide d'une table BigQuery contenant une version de ces données sur les haricots. L'ensemble de données sera transmis en entrée à notre job d'entraînement. Dans notre code d'entraînement, nous aurons accès à la variable d'environnement pour accéder à cet ensemble de données géré.
Voici comment nous allons configurer notre job d'entraînement personnalisé :
- Écrire un modèle Scikit-learn
DecisionTreeClassifierpour classer les types de haricots dans nos données - Empaqueter le code d'entraînement dans un conteneur Docker et l'envoyer à Container Registry
À partir de là, nous pourrons démarrer un job Vertex AI Training directement à partir de notre pipeline. C'est parti !
Étape 1 : Définissez notre code d'entraînement dans un conteneur Docker
Dans votre instance Notebooks, ouvrez le lanceur et sélectionnez "Terminal" :
Exécutez ensuite la commande suivante pour configurer un répertoire dans lequel vous ajouterez votre code conteneurisé :
mkdir traincontainer
cd traincontainer
touch Dockerfile
mkdir trainer
touch trainer/train.py
Après avoir exécuté ces commandes, vous devriez voir un répertoire nommé traincontainer/ créé sur la gauche (vous devrez peut-être cliquer sur l'icône d'actualisation pour le voir). Votre répertoire traincontainer/ doit contenir les éléments suivants :
+ Dockerfile
+ trainer/
+ train.py
La première étape de la conteneurisation de notre code consiste à créer un Dockerfile. Dans notre Dockerfile, nous allons inclure toutes les commandes nécessaires à l'exécution de notre image. Ce fichier servira à installer toutes les bibliothèques requises et à configurer le point d'entrée de notre code d'entraînement. Ouvrez le fichier Dockerfile que vous venez de créer et ajoutez-y le code suivant :
FROM gcr.io/deeplearning-platform-release/sklearn-cpu.0-23
WORKDIR /
# Copies the trainer code to the docker image.
COPY trainer /trainer
RUN pip install sklearn google-cloud-bigquery joblib pandas google-cloud-storage
# Sets up the entry point to invoke the trainer.
ENTRYPOINT ["python", "-m", "trainer.train"]
Pour enregistrer des fichiers pendant que vous les modifiez dans votre instance de notebook, vous pouvez utiliser ctrl+s.
Ouvrez ensuite le fichier train.py. C'est là que nous ajouterons notre code d'entraînement. Copiez ce qui suit dans train.py. Cette opération récupère les données de notre ensemble de données géré, les place dans un DataFrame Pandas, entraîne un modèle Scikit-learn et importe le modèle entraîné dans Cloud Storage :
from sklearn.tree import DecisionTreeClassifier
from sklearn.metrics import roc_curve
from sklearn.model_selection import train_test_split
from google.cloud import bigquery
from google.cloud import storage
from joblib import dump
import os
import pandas as pd
bqclient = bigquery.Client()
storage_client = storage.Client()
def download_table(bq_table_uri: str):
prefix = "bq://"
if bq_table_uri.startswith(prefix):
bq_table_uri = bq_table_uri[len(prefix):]
table = bigquery.TableReference.from_string(bq_table_uri)
rows = bqclient.list_rows(
table,
)
return rows.to_dataframe(create_bqstorage_client=False)
# These environment variables are from Vertex AI managed datasets
training_data_uri = os.environ["AIP_TRAINING_DATA_URI"]
test_data_uri = os.environ["AIP_TEST_DATA_URI"]
# Download data into Pandas DataFrames, split into train / test
df = download_table(training_data_uri)
test_df = download_table(test_data_uri)
labels = df.pop("Class").tolist()
data = df.values.tolist()
test_labels = test_df.pop("Class").tolist()
test_data = test_df.values.tolist()
# Define and train the Scikit model
skmodel = DecisionTreeClassifier()
skmodel.fit(data, labels)
score = skmodel.score(test_data, test_labels)
print('accuracy is:',score)
# Save the model to a local file
dump(skmodel, "model.joblib")
# Upload the saved model file to GCS
bucket = storage_client.get_bucket("YOUR_GCS_BUCKET")
model_directory = os.environ["AIP_MODEL_DIR"]
storage_path = os.path.join(model_directory, "model.joblib")
blob = storage.blob.Blob.from_string(storage_path, client=storage_client)
blob.upload_from_filename("model.joblib")
Revenez ensuite à votre notebook et exécutez la commande suivante pour remplacer YOUR_GCS_BUCKET dans le script ci-dessus par le nom de votre bucket Cloud Storage :
BUCKET = BUCKET_NAME[5:] # Trim the 'gs://' before adding to train script
!sed -i -r 's@YOUR_GCS_BUCKET@'"$BUCKET"'@' traincontainer/trainer/train.py
Vous pouvez également le faire manuellement si vous le souhaitez. Si vous le faites, veillez à ne pas inclure gs:// dans le nom de votre bucket lorsque vous mettez à jour le script.
Notre code d'entraînement se trouve maintenant dans un conteneur Docker. Nous sommes prêts à exécuter l'entraînement dans le cloud.
Étape 2 : Stockez le conteneur dans Container Registry
Maintenant que notre code d'entraînement est terminé, nous pouvons le transférer vers Google Container Registry. Plus tard, lorsque nous configurerons le composant d'entraînement de notre pipeline, nous indiquerons à Vertex Pipelines ce conteneur.
Revenez à votre terminal et, à partir de la racine de votre répertoire traincontainer/, définissez une variable avec l'URI de votre image de conteneur dans Container Registry.
PROJECT_ID=$(gcloud config get-value project)
IMAGE_URI="gcr.io/$PROJECT_ID/scikit:v1"
Ensuite, créez votre conteneur en exécutant la commande suivante :
docker build ./ -t $IMAGE_URI
Enfin, transférez le conteneur vers Container Registry :
docker push $IMAGE_URI
Accédez à la section Container Registry de la console Cloud pour vérifier que votre conteneur s'y trouve. La requête doit ressembler à ceci :
6. Configurer une tâche de prédiction par lot
La dernière étape de notre pipeline exécutera un job de prédiction par lot. Pour que cela fonctionne, nous devons fournir un fichier CSV dans Cloud Storage contenant les exemples pour lesquels nous souhaitons obtenir des prédictions. Nous allons créer ce fichier CSV dans notre notebook et le copier dans Cloud Storage à l'aide de l'outil de ligne de commande gsutil.
Copier des exemples de prédiction par lots dans Cloud Storage
Le fichier suivant contient trois exemples de chaque classe de notre ensemble de données sur les haricots. L'exemple ci-dessous n'inclut pas la colonne Class, car c'est ce que notre modèle prédira. Exécutez la commande suivante pour créer ce fichier CSV localement dans votre notebook :
%%writefile batch_examples.csv
Area,Perimeter,MajorAxisLength,MinorAxisLength,AspectRation,Eccentricity,ConvexArea,EquivDiameter,Extent,Solidity,roundness,Compactness,ShapeFactor1,ShapeFactor2,ShapeFactor3,ShapeFactor4
23288,558.113,207.567738,143.085693,1.450653336,0.7244336162,23545,172.1952453,0.8045881703,0.9890847314,0.9395021523,0.8295857874,0.008913077034,0.002604069884,0.6882125787,0.9983578734
23689,575.638,205.9678003,146.7475015,1.403552348,0.7016945718,24018,173.6714472,0.7652721693,0.9863019402,0.8983750474,0.8431970773,0.00869465998,0.002711119968,0.7109813112,0.9978994889
23727,559.503,189.7993849,159.3717704,1.190922235,0.5430731512,24021,173.8106863,0.8037601626,0.9877607094,0.952462433,0.9157600082,0.007999299741,0.003470231343,0.8386163926,0.9987269085
31158,641.105,212.0669751,187.1929601,1.132879009,0.4699241567,31474,199.1773023,0.7813134733,0.989959967,0.9526231013,0.9392188582,0.0068061806,0.003267009878,0.8821320637,0.9993488983
32514,649.012,221.4454899,187.1344232,1.183349841,0.5346736437,32843,203.4652564,0.7849831,0.9899826447,0.9700068737,0.9188051492,0.00681077351,0.002994124691,0.8442029022,0.9989873701
33078,659.456,235.5600775,178.9312328,1.316483846,0.6503915309,33333,205.2223615,0.7877214708,0.9923499235,0.9558229607,0.8712102818,0.007121351881,0.002530662194,0.7590073551,0.9992209221
33680,683.09,256.203255,167.9334938,1.525623324,0.7552213942,34019,207.081404,0.80680321,0.9900349805,0.9070392732,0.8082699962,0.007606985006,0.002002710402,0.6533003868,0.9966903078
33954,716.75,277.3684803,156.3563259,1.773951126,0.825970469,34420,207.9220419,0.7994819873,0.9864613597,0.8305492781,0.7496238998,0.008168948587,0.001591181142,0.5619359911,0.996846984
36322,719.437,272.0582306,170.8914975,1.591993952,0.7780978465,36717,215.0502424,0.7718560075,0.9892420405,0.8818487005,0.7904566678,0.007490177594,0.001803782407,0.6248217437,0.9947124371
36675,742.917,285.8908964,166.8819538,1.713132487,0.8119506999,37613,216.0927123,0.7788277766,0.9750618137,0.8350248381,0.7558572692,0.0077952528,0.001569528272,0.5713202115,0.9787472145
37454,772.679,297.6274753,162.1493177,1.835514817,0.8385619338,38113,218.3756257,0.8016695205,0.9827093118,0.7883332637,0.7337213257,0.007946480356,0.001420623993,0.5383469838,0.9881438654
37789,766.378,313.5680678,154.3409867,2.031657789,0.8704771226,38251,219.3500608,0.7805870567,0.9879218844,0.8085170916,0.6995293312,0.008297866252,0.001225659709,0.4893412853,0.9941740339
47883,873.536,327.9986493,186.5201272,1.758516115,0.822571799,48753,246.9140116,0.7584464543,0.9821549443,0.7885506623,0.7527897207,0.006850002074,0.00135695419,0.5666923636,0.9965376533
49777,861.277,300.7570338,211.6168613,1.42123379,0.7105823885,50590,251.7499649,0.8019106536,0.9839296304,0.843243269,0.8370542883,0.00604208839,0.001829706116,0.7006598815,0.9958014989
49882,891.505,357.1890036,179.8346914,1.986207449,0.8640114945,51042,252.0153467,0.7260210171,0.9772736178,0.7886896753,0.7055518063,0.007160679276,0.001094585314,0.4978033513,0.9887407248
53249,919.923,325.3866286,208.9174205,1.557489212,0.7666552108,54195,260.3818974,0.6966846347,0.9825445152,0.7907120655,0.8002231025,0.00611066177,0.001545654241,0.6403570138,0.9973491406
61129,964.969,369.3481688,210.9473449,1.750902193,0.8208567513,61796,278.9836198,0.7501135067,0.9892064211,0.8249553283,0.7553404711,0.006042110436,0.001213219664,0.5705392272,0.9989583843
61918,960.372,353.1381442,224.0962377,1.575832543,0.7728529173,62627,280.7782864,0.7539207091,0.9886790043,0.8436218213,0.7950947556,0.005703319619,0.00140599258,0.6321756704,0.9962029945
141953,1402.05,524.2311633,346.3974998,1.513380332,0.7505863011,143704,425.1354762,0.7147107987,0.9878152313,0.9074598849,0.8109694843,0.003692991084,0.0009853172185,0.6576715044,0.9953071199
145285,1440.991,524.9567463,353.0769977,1.486805285,0.7400216694,146709,430.0960442,0.7860466375,0.9902937107,0.8792413513,0.8192980608,0.003613289371,0.001004269363,0.6712493125,0.9980170255
146153,1476.383,526.1933264,356.528288,1.475881001,0.7354662103,149267,431.3789276,0.7319360978,0.9791380546,0.8425962592,0.8198107159,0.003600290972,0.001003163512,0.6720896099,0.991924286
Copiez ensuite le fichier dans votre bucket Cloud Storage :
!gsutil cp batch_examples.csv $BUCKET_NAME
Nous ferons référence à ce fichier à l'étape suivante, lorsque nous définirons notre pipeline.
7. Créer un pipeline avec des composants prédéfinis
Maintenant que notre code d'entraînement est dans le cloud, nous pouvons l'appeler depuis notre pipeline. Le pipeline que nous allons définir utilisera trois composants prédéfinis de la bibliothèque google_cloud_pipeline_components que nous avons installée précédemment. Ces composants prédéfinis simplifient le code que nous devons écrire pour configurer notre pipeline et nous permettront d'utiliser les services Vertex AI tels que l'entraînement de modèles et la prédiction par lot.
Voici ce que fera notre pipeline en trois étapes :
- Créer un ensemble de données géré dans Vertex AI
- Exécuter un job d'entraînement sur Vertex AI à l'aide du conteneur personnalisé que nous avons configuré
- Exécuter un job de prédiction par lot sur notre modèle de classification Scikit-learn entraîné
Étape 1 : Définir notre pipeline
Comme nous utilisons des composants prédéfinis, nous pouvons configurer l'ensemble de notre pipeline dans la définition du pipeline. Ajoutez le code suivant à une cellule de notebook :
@pipeline(name="automl-beans-custom",
pipeline_root=PIPELINE_ROOT)
def pipeline(
bq_source: str = "bq://sara-vertex-demos.beans_demo.large_dataset",
bucket: str = BUCKET_NAME,
project: str = PROJECT_ID,
gcp_region: str = REGION,
bq_dest: str = "",
container_uri: str = "",
batch_destination: str = ""
):
dataset_create_op = gcc_aip.TabularDatasetCreateOp(
display_name="tabular-beans-dataset",
bq_source=bq_source,
project=project,
location=gcp_region
)
training_op = gcc_aip.CustomContainerTrainingJobRunOp(
display_name="pipeline-beans-custom-train",
container_uri=container_uri,
project=project,
location=gcp_region,
dataset=dataset_create_op.outputs["dataset"],
staging_bucket=bucket,
training_fraction_split=0.8,
validation_fraction_split=0.1,
test_fraction_split=0.1,
bigquery_destination=bq_dest,
model_serving_container_image_uri="us-docker.pkg.dev/vertex-ai/prediction/sklearn-cpu.0-24:latest",
model_display_name="scikit-beans-model-pipeline",
machine_type="n1-standard-4",
)
batch_predict_op = gcc_aip.ModelBatchPredictOp(
project=project,
location=gcp_region,
job_display_name="beans-batch-predict",
model=training_op.outputs["model"],
gcs_source_uris=["{0}/batch_examples.csv".format(BUCKET_NAME)],
instances_format="csv",
gcs_destination_output_uri_prefix=batch_destination,
machine_type="n1-standard-4"
)
Étape 2 : Compilez et exécutez le pipeline
Une fois que vous avez défini votre pipeline, vous pouvez le compiler. Le code suivant génère un fichier JSON qui vous permettra d'exécuter le pipeline :
compiler.Compiler().compile(
pipeline_func=pipeline, package_path="custom_train_pipeline.json"
)
Ensuite, créez une variable TIMESTAMP. Nous l'utiliserons dans notre ID de job :
from datetime import datetime
TIMESTAMP = datetime.now().strftime("%Y%m%d%H%M%S")
Définissez ensuite votre job de pipeline en transmettant quelques paramètres spécifiques au projet :
pipeline_job = aiplatform.PipelineJob(
display_name="custom-train-pipeline",
template_path="custom_train_pipeline.json",
job_id="custom-train-pipeline-{0}".format(TIMESTAMP),
parameter_values={
"project": PROJECT_ID,
"bucket": BUCKET_NAME,
"bq_dest": "bq://{0}".format(PROJECT_ID),
"container_uri": "gcr.io/{0}/scikit:v1".format(PROJECT_ID),
"batch_destination": "{0}/batchpredresults".format(BUCKET_NAME)
},
enable_caching=True,
)
Enfin, exécutez le job pour créer une exécution de pipeline :
pipeline_job.submit()
Après avoir exécuté cette cellule, vous devriez voir des journaux avec un lien permettant de consulter l'exécution du pipeline dans votre console :
Accédez à ce lien. Vous pouvez également y accéder en ouvrant le tableau de bord des pipelines. Une fois terminé, votre pipeline doit ressembler à ceci :
L'exécution de ce pipeline prend cinq à dix minutes, mais vous pouvez passer à l'étape suivante avant qu'il ne soit terminé. Vous en apprendrez ensuite davantage sur ce qui se passe à chacune de ces étapes du pipeline.
8. Comprendre l'exécution de votre pipeline
Examinons plus en détail chacune des trois étapes du pipeline.
Étape 1 du pipeline : Créer un ensemble de données géré
La première étape de notre pipeline consiste à créer un ensemble de données géré dans Vertex AI. Si vous cliquez sur le lien de l'ensemble de données suivant dans la section "Pipelines" de votre console :
Votre ensemble de données s'affiche dans Vertex AI. Il inclut un lien vers la source de données dans BigQuery, ainsi que des informations sur les différentes colonnes de votre ensemble de données. Une fois que vous avez importé un ensemble de données géré dans Vertex AI, vous pouvez l'utiliser pour entraîner un modèle AutoML ou personnalisé.
Pour les jobs de modèle personnalisé qui utilisent des ensembles de données gérés, Vertex AI transmet des variables d'environnement spéciales à vos jobs d'entraînement et gère la répartition de vos données en ensembles d'entraînement et de test. Nous l'utiliserons à la prochaine étape du pipeline.
Étape 2 du pipeline : Entraîner un modèle dans Vertex AI Training
Pendant l'exécution de votre job d'entraînement personnalisé, vous pouvez cliquer pour afficher les journaux directement dans la console Vertex Pipelines :
Vous pouvez également consulter les détails du job d'entraînement personnalisé dans votre tableau de bord Training Vertex AI. Une fois le job d'entraînement terminé, une ressource de modèle est créée dans Vertex AI. Nous pouvons ensuite déployer ce modèle sur un point de terminaison pour obtenir des prédictions en ligne ou créer un job de prédiction par lot, ce que nous ferons à la prochaine étape du pipeline.
Étape 3 du pipeline : Exécuter un job de prédiction par lot sur notre modèle
Enfin, notre pipeline obtiendra des prédictions sur les exemples que nous avons transmis via un fichier CSV. Une fois le job de prédiction par lot terminé, Vertex AI écrit un fichier CSV à l'emplacement que nous avons spécifié dans Cloud Storage. Lorsque cette étape du pipeline commence à s'exécuter, vous pouvez accéder à la section "Prédictions par lot" de votre console Vertex AI pour afficher le job créé.
Une fois le job terminé, cliquez dessus pour afficher l'URL Cloud Storage de vos prédictions par lot :
Cliquez sur ce lien pour accéder au répertoire Cloud Storage où se trouvent les résultats de prédiction, puis cliquez pour télécharger l'un des fichiers prediction.results. Dans le fichier, vous devriez voir des lignes semblables à celles-ci :
{"instance": [33954.0, 716.75, 277.3684803, 156.3563259, 1.773951126, 0.825970469, 34420.0, 207.9220419, 0.7994819873, 0.9864613597, 0.8305492781, 0.7496238998, 0.008168948587, 0.001591181142, 0.5619359911, 0.996846984], "prediction": "HOROZ"}
Cela inclut les valeurs des caractéristiques pour une instance particulière, ainsi que la classe prédite par notre modèle. Dans cet exemple, notre modèle pense qu'il s'agit d'un haricot "HOROZ".
Vous avez terminé l'atelier.
🎉 Félicitations ! 🎉
Vous savez désormais utiliser Vertex AI pour :
- Utiliser le SDK Kubeflow Pipelines pour créer des pipelines de bout en bout avec des composants personnalisés
- Exécuter vos pipelines sur Vertex Pipelines et lancer des exécutions de pipeline avec le SDK
- Afficher et analyser votre graphique Vertex Pipelines dans la console
- Utiliser des composants de pipeline prédéfinis pour ajouter des services Vertex AI à votre pipeline
- Planifier des jobs de pipeline récurrents
Pour en savoir plus sur les différents composants de Vertex, consultez la documentation.
9. Nettoyage
Pour éviter que des frais ne vous soient facturés, nous vous recommandons de supprimer les ressources créées tout au long de cet atelier.
Étape 1 : Arrêtez ou supprimez votre instance de notebooks
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 l'instance définitivement, sélectionnez Supprimer :
Étape 2 : Supprimez votre bucket Cloud Storage
Pour supprimer le bucket de stockage, utilisez le menu de navigation de la console Cloud pour accéder à Stockage, sélectionnez votre bucket puis cliquez sur "Supprimer" :
