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 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 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.
Résumé: les pipelines vous aident à simplifier 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
En haut à droite 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 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 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, parmi lesquelles 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 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é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 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 :
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: 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 (que 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. Nous allons ensuite 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 vous utiliserez 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. Il 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 tâche 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 (haricots secs) 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 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 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 l'envoyer vers Container Registry
Nous pourrons ensuite démarrer un job d'entraînement Vertex AI directement à partir de notre pipeline. C'est parti !
Étape 1: Définir notre code d'entraînement dans un conteneur Docker
Dans votre instance Notebooks, ouvrez le lanceur d'applications 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
Une fois ces commandes exécutées, un répertoire nommé traincontainer/ doit être 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. 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.
Ouvrez ensuite le fichier train.py. C'est là que nous allons ajouter notre code d'entraînement. Copiez le code suivant dans train.py. Cela permet de récupérer les données de notre ensemble de données géré, de les placer dans un DataFrame Pandas, d'entraîner un modèle Scikit-learn et d'importer 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")
Ensuite, revenez à 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 préférez. Dans ce cas, veillez à ne pas inclure gs:// dans le nom du 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: Stocker le conteneur dans Container Registry
Une fois le 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"
Créez ensuite votre conteneur en exécutant la commande suivante:
docker build ./ -t $IMAGE_URI
Enfin, stockez le conteneur dans Container Registry:
docker push $IMAGE_URI
Accédez à la section Container Registry de la console Cloud pour vérifier que votre conteneur y figure. La requête doit ressembler à ceci :
6. Configurer une tâche de prédiction par lot
La dernière étape de notre 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 notre 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
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 à partir de 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 permettent d'utiliser les services Vertex AI, tels que l'entraînement de modèles et la prédiction par lot.
Voici ce que notre pipeline en trois étapes va faire:
- 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
Étant donné que 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 la tâche pour créer une exécution de pipeline:
pipeline_job.submit()
Une fois cette cellule exécutée, des journaux s'affichent 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 votre tableau de bord Pipelines. Une fois l'exécution terminée, votre pipeline doit ressembler à ceci:
L'exécution de ce pipeline prendra 5 à 10 minutes, mais vous pouvez passer à l'étape suivante avant qu'elle ne soit terminée. 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 de l'ensemble de données suivant dans la section "Pipelines" de la console:
Votre ensemble de données s'affiche dans Vertex AI, avec 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înement d'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 des informations sur la tâche d'entraînement personnalisé dans le tableau de bord de l'entraînement de 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 une tâche 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 notre modèle
Enfin, notre pipeline obtiendra des prédictions sur les exemples que nous avons transmis via un fichier CSV. Une fois la tâche de prédiction par lot terminée, Vertex AI écrit un fichier CSV à l'emplacement que vous avez 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 où se trouvent les résultats de la 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 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 définitivement l'instance, sélectionnez Delete (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" :
