1. Présentation
Dans cet atelier, vous allez apprendre à exécuter un job d'entraînement de modèle personnalisé dans Vertex Pipelines à l'aide du SDK Kubeflow 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 par 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 les offres de ML de Google sur Google Cloud pour vous offrir une expérience de développement fluide. 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.
Les pipelines tl;dr 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émarrez Cloud Shell
Dans cet atelier, vous allez travailler dans une session Cloud Shell, un interpréteur de commandes hébergé par une machine virtuelle exécutée 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
Dans l'angle supérieur droit de la console Cloud, cliquez sur le bouton ci-dessous pour activer Cloud Shell:
Si vous n'avez jamais démarré Cloud Shell auparavant, un écran intermédiaire (en dessous de la ligne de flottaison) vous explique de quoi il s'agit. Dans ce cas, cliquez sur Continuer (elle ne s'affichera plus). 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 devrait 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, y compris GOOGLE_CLOUD_PROJECT qui contient le nom de notre projet Cloud actuel. Nous l'utiliserons à différents 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 nécessaires (et pourquoi). Pour le moment, exécutez la commande suivante afin d'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éez un bucket Cloud Storage
Pour exécuter un job d'entraînement sur Vertex AI, nous avons besoin d'un bucket de stockage afin de stocker les ressources de modèle enregistrées. Ce bucket doit être régional. Nous utilisons ici us-central, mais vous pouvez utiliser une autre région (il vous suffit de la remplacer 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 maintenant autoriser notre compte de service Compute à accéder à ce bucket. Vertex Pipelines disposera ainsi 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 :
Ensuite, 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: il s'agit du 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 (à laquelle vous pouvez accéder 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 noyau :
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. Ensuite, nous allons créer des variables pour chacun de ces éléments.
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 les éléments suivants pour importer les bibliothèques que nous utiliserons tout au long de 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, mettez à jour 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. Il est 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 sur les haricots secs de l'UCI Machine Learning, provenant 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 du 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 tant qu'entrée à notre job d'entraînement. Dans notre code d'entraînement, nous aurons accès à une variable d'environnement pour accéder à cet ensemble de données géré.
Voici comment configurer le job d'entraînement personnalisé:
- Écrire un modèle
DecisionTreeClassifierscikit-learn pour classer les types de haricots dans nos données - Empaqueter le code d'entraînement dans un conteneur Docker et le transférer vers Container Registry
Nous pourrons alors démarrer un job Vertex AI Training directement depuis notre pipeline. C'est parti !
Étape 1: Définir le code d'entraînement dans un conteneur Docker
À partir de votre instance Notebooks, ouvrez le lanceur d'applications et sélectionnez "Terminal" :
Ensuite, exécutez 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 appelé traincontainer/ créé à gauche (vous devrez peut-être cliquer sur l'icône d'actualisation pour le voir). Le répertoire traincontainer/ s'affiche comme suit:
+ Dockerfile
+ trainer/
+ train.py
La première étape de la conteneurisation de notre code consiste à créer un Dockerfile. Nous allons inclure toutes les commandes nécessaires à l'exécution de l'image dans notre Dockerfile. Il installera toutes les bibliothèques que nous utilisons et configurera le point d'entrée de notre code d'entraînement. Ouvrez le Dockerfile que vous venez de créer et ajoutez ce qui suit:
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 à mesure que vous les modifiez dans votre instance de notebook, vous pouvez utiliser ctrl+s.
Ensuite, ouvrez le fichier train.py. C'est ici que nous allons ajouter notre code d'entraînement. Copiez le code suivant 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 du 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 effectuer cette opération manuellement si vous le souhaitez. Dans ce cas, 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 et nous sommes prêts à exécuter l'entraînement dans le cloud.
Étape 2: Transférez le conteneur vers Container Registry
Une fois notre code d'entraînement terminé, nous pouvons transférer cela 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 sur 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 le conteneur s'y trouve. La requête doit ressembler à ceci :
6. Configurer une tâche de prédiction par lot
La dernière étape du pipeline consiste à exécuter un job de prédiction par lot. Pour que cela fonctionne, nous devons fournir dans Cloud Storage un fichier CSV contenant les exemples sur lesquels nous voulons 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 lot 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 le modèle va prédire. 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
Ensuite, copiez 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 sommes prêts à l'appeler depuis notre pipeline. Le pipeline que nous allons définir utilisera trois composants prédéfinis issus de la bibliothèque google_cloud_pipeline_components que nous avons installée précédemment. Ces composants prédéfinis simplifient le code à écrire pour configurer notre pipeline et nous permettent d'utiliser les services Vertex AI tels que l'entraînement de modèles et la prédiction par lot.
Voici à quoi sert 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 Vertx 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 tâche:
from datetime import datetime
TIMESTAMP = datetime.now().strftime("%Y%m%d%H%M%S")
Ensuite, définissez 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 d'afficher 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 l'opération terminée, votre pipeline doit se présenter comme suit:
L'exécution de ce pipeline prendra 5 à 10 minutes, mais vous pouvez passer à l'étape suivante avant la fin. Vous allez maintenant en apprendre 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 d'ensemble de données suivant dans la section "Pipelines" de votre console:
Votre ensemble de données s'affiche dans Vertex AI. Il comprend 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 un modèle 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 division de vos données en ensembles d'entraînement et de test. Nous l'utiliserons à l'étape suivante 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 d'entraînement 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 les prédictions en ligne ou créer un job de prédiction par lot, ce que nous ferons à l'étape suivante du pipeline.
Étape 3 du pipeline: Exécuter un job de prédiction par lot sur le modèle
Enfin, notre pipeline obtiendra des prédictions sur les exemples 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éé.
Cliquez sur la tâche une fois qu'elle est terminée pour afficher l'URL Cloud Storage de vos prédictions par lot:
Cliquez sur ce lien pour accéder au répertoire Cloud Storage, qui contient les résultats de la prédiction, puis cliquez sur l'un des fichiers prediction.results pour le télécharger. Dans le fichier, les lignes qui se présentent comme suit doivent s'afficher:
{"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 d'une instance particulière, ainsi que la classe prédite par notre modèle. Dans cet exemple, notre modèle considère qu'il s'agit d'une annonce "HOROZ" fève.
Vous avez maintenant 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 leurs exécutions avec le SDK
- Afficher et analyser votre graphique Vertex Pipelines dans la console
- Ajouter des services Vertex AI à votre pipeline à l'aide de composants prédéfinis
- Planifier des jobs de pipeline récurrents
Pour en savoir plus sur les différents composants de Vertex, consultez la documentation.
9. Nettoyage
Pour ne pas être facturé, nous vous recommandons de supprimer les ressources créées tout au long de cet atelier.
Étape 1: Arrêtez ou supprimez votre instance 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 entièrement l'instance, 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" :
