1. Panoramica
In questo lab imparerai a eseguire un job di addestramento di modelli personalizzati utilizzando l'SDK Kubeflow Pipelines su Vertex Pipelines.
Cosa imparerai
Al termine del corso sarai in grado di:
- Utilizzare l'SDK Kubeflow Pipelines per creare pipeline ML scalabili
- Creare e conteggiare un job di addestramento del modello Scikit-learn personalizzato che utilizza i set di dati gestiti di Vertex AI e verrà eseguito in Vertex AI Training all'interno di una pipeline
- Esegui un job di previsione batch in Vertex Pipelines
- Usa componenti predefiniti per interagire con i servizi Vertex AI, forniti tramite la libreria
google_cloud_pipeline_components
Il costo totale per l'esecuzione di questo lab su Google Cloud è di circa 5$.
2. Introduzione a Vertex AI
Questo lab utilizza Vertex AI, la nostra piattaforma ML gestita end-to-end su Google Cloud. Vertex AI integra le offerte ML di Google su Google Cloud in un'esperienza di sviluppo fluida. Oltre ai servizi di addestramento e deployment dei modelli, Vertex AI include anche una varietà di prodotti MLOps, tra cui Vertex Pipelines (l'aspetto su cui si concentra questo lab), Model Monitoring, Feature Store e altri. Puoi vedere tutte le offerte di prodotti Vertex AI nel diagramma seguente.
In caso di feedback, consulta la pagina di assistenza.
Perché le pipeline ML sono utili?
Prima di entrare nel dettaglio dell'argomento, capiamo innanzitutto perché potresti voler utilizzare una pipeline. Immagina di creare un flusso di lavoro ML che includa l'elaborazione dei dati, l'addestramento di un modello, l'ottimizzazione degli iperparametri, la valutazione e il deployment del modello. Ciascuno di questi passaggi può avere dipendenze diverse, che potrebbero diventare difficili da gestire se consideri l'intero flusso di lavoro come un monolite. Quando inizi a scalare il tuo processo ML, potresti voler condividere il tuo flusso di lavoro ML con altri membri del tuo team in modo che possano eseguirlo e contribuire al codice. Senza un processo affidabile e riproducibile, questo può diventare difficile. Con le pipeline, ogni passaggio del processo ML è un container a sé stante. Ciò consente di sviluppare passaggi in modo indipendente e tenere traccia dell'input e output di ciascun passaggio in modo riproducibile. Puoi anche pianificare o attivare esecuzioni della pipeline in base ad altri eventi nel tuo ambiente Cloud, ad esempio l'avvio di un'esecuzione della pipeline quando sono disponibili nuovi dati di addestramento.
In breve: le pipeline ti aiutano a semplificare e riprodurre i flussi di lavoro ML.
3. Configurazione dell'ambiente cloud
Per eseguire questo codelab, devi avere un progetto Google Cloud con la fatturazione abilitata. Per creare un progetto, segui le istruzioni riportate qui.
Passaggio 1: avvia Cloud Shell
In questo lab lavorerai in una sessione di Cloud Shell, un interprete di comandi ospitato da una macchina virtuale in esecuzione nel cloud di Google. Potresti eseguire facilmente questa sezione in locale sul tuo computer, ma l'utilizzo di Cloud Shell offre a chiunque l'accesso a un'esperienza riproducibile in un ambiente coerente. Dopo il lab, puoi riprovare questa sezione sul tuo computer.
Attiva Cloud Shell
In alto a destra nella console Cloud, fai clic sul pulsante in basso per attivare Cloud Shell:
Se non hai mai avviato Cloud Shell, viene visualizzata una schermata intermedia (sotto la piega) che descrive di cosa si tratta. In questo caso, fai clic su Continua (e non la vedrai mai più). Ecco come appare la schermata una tantum:
Dovrebbero bastare pochi istanti per eseguire il provisioning e connettersi a Cloud Shell.
Questa macchina virtuale viene caricata con tutti gli strumenti di sviluppo di cui hai bisogno. Offre una home directory permanente da 5 GB e viene eseguita in Google Cloud, migliorando notevolmente le prestazioni e l'autenticazione della rete. Gran parte, se non tutto, del lavoro in questo codelab può essere svolto semplicemente con un browser o con il tuo Chromebook.
Una volta eseguita la connessione a Cloud Shell, dovresti vedere che il tuo account è già autenticato e il progetto è già impostato sul tuo ID progetto.
Esegui questo comando in Cloud Shell per verificare che l'account sia autenticato:
gcloud auth list
L'output del comando dovrebbe essere simile al seguente:
Esegui il seguente comando in Cloud Shell per verificare che il comando gcloud conosca il tuo progetto:
gcloud config list project
Output comando
[core] project = <PROJECT_ID>
In caso contrario, puoi impostarlo con questo comando:
gcloud config set project <PROJECT_ID>
Output comando
Updated property [core/project].
Cloud Shell include alcune variabili di ambiente, tra cui GOOGLE_CLOUD_PROJECT che contiene il nome del nostro progetto Cloud corrente. Lo utilizzeremo in vari punti di questo lab. Puoi visualizzarla eseguendo questo comando:
echo $GOOGLE_CLOUD_PROJECT
Passaggio 2: attivazione delle API
Nei passaggi successivi vedrai dove (e perché) sono necessari questi servizi, ma per il momento esegui questo comando per concedere al tuo progetto l'accesso ai servizi Compute Engine, Container Registry e Vertex AI:
gcloud services enable compute.googleapis.com \
containerregistry.googleapis.com \
aiplatform.googleapis.com
Dovrebbe essere visualizzato un messaggio di operazione riuscita simile a questo:
Operation "operations/acf.cc11852d-40af-47ad-9d59-477a12847c9e" finished successfully.
Passaggio 3: crea un bucket Cloud Storage
Per eseguire un job di addestramento su Vertex AI, abbiamo bisogno di un bucket di archiviazione in cui archiviare gli asset salvati nel modello. Il bucket deve essere regionale. Qui utilizziamo us-central, ma puoi anche usare un'altra regione (basta sostituirla in questo lab). Se hai già un bucket, puoi saltare questo passaggio.
Esegui questi comandi nel terminale Cloud Shell per creare un bucket:
BUCKET_NAME=gs://$GOOGLE_CLOUD_PROJECT-bucket
gsutil mb -l us-central1 $BUCKET_NAME
A questo punto concediamo al nostro service account Compute l'accesso al bucket. In questo modo, Vertex Pipelines avrà le autorizzazioni necessarie per scrivere file in questo bucket. Esegui questo comando per aggiungere l'autorizzazione:
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
Passaggio 4: crea un'istanza di Vertex AI Workbench
Dalla sezione Vertex AI della console Cloud, fai clic su Workbench:
Da qui, fai clic su Nuovo blocco note in Blocchi note gestiti dall'utente:
Quindi seleziona il tipo di istanza TensorFlow Enterprise 2.3 (con LTS) senza GPU:
Utilizza le opzioni predefinite e poi fai clic su Crea.
Passaggio 5: apri il blocco note
Una volta creata l'istanza, seleziona Apri JupyterLab:
4. Configurazione di Vertex Pipelines
Per utilizzare Vertex Pipelines, dovremo installare alcune librerie aggiuntive:
- Kubeflow Pipelines: questo è l'SDK che utilizzeremo per creare la pipeline. Vertex Pipelines supporta l'esecuzione di pipeline create sia con Kubeflow Pipelines che con TFX.
- Componenti della pipeline di Google Cloud: questa libreria fornisce componenti predefiniti che semplificano l'interazione con i servizi Vertex AI dai passaggi della pipeline.
Passaggio 1: crea un notebook Python e installa le librerie
Innanzitutto, dal menu Avvio nell'istanza del notebook (a cui puoi accedere facendo clic sull'icona + in alto a sinistra del notebook), crea un notebook selezionando Python 3:
Puoi accedere al menu Avvio app facendo clic sul segno + in alto a sinistra dell'istanza del notebook.
Per installare entrambi i servizi che utilizzeremo in questo lab, imposta prima il flag utente nella cella di un blocco note:
USER_FLAG = "--user"
Poi esegui il codice seguente dal blocco note:
!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
Dopo aver installato questi pacchetti, dovrai riavviare il 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)
Infine, verifica di aver installato correttamente i pacchetti. La versione dell'SDK KFP deve essere >=1.8:
!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__))"
Passaggio 2: imposta l'ID progetto e il bucket
In questo lab farai riferimento all'ID progetto Cloud e al bucket che hai creato in precedenza. Poi creeremo variabili per ciascuno di questi.
Se non conosci l'ID progetto, potresti riuscire a recuperarlo eseguendo quanto segue:
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)
In caso contrario, impostalo qui:
if PROJECT_ID == "" or PROJECT_ID is None:
PROJECT_ID = "your-project-id" # @param {type:"string"}
Quindi, crea una variabile per archiviare il nome del bucket. Se lo hai creato in questo lab, la seguente operazione funzionerà. In caso contrario, dovrai impostarla manualmente:
BUCKET_NAME="gs://" + PROJECT_ID + "-bucket"
Passaggio 3: importa le librerie
Aggiungi quanto segue per importare le librerie che utilizzeremo in questo codelab:
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
Passaggio 4: definisci le costanti
L'ultima cosa che dobbiamo fare prima di creare la pipeline è definire alcune variabili costanti. PIPELINE_ROOT è il percorso di Cloud Storage in cui verranno scritti gli elementi creati dalla nostra pipeline. Qui utilizziamo us-central1 come regione, ma se hai utilizzato una regione diversa quando hai creato il bucket, aggiorna la variabile REGION nel codice seguente:
PATH=%env PATH
%env PATH={PATH}:/home/jupyter/.local/bin
REGION="us-central1"
PIPELINE_ROOT = f"{BUCKET_NAME}/pipeline_root/"
PIPELINE_ROOT
Dopo aver eseguito il codice riportato sopra, dovresti vedere la directory root della pipeline stampata. Questa è la posizione di Cloud Storage in cui verranno scritti gli elementi della pipeline. Il formato sarà gs://YOUR-BUCKET-NAME/pipeline_root/
5. Configurazione di un job di addestramento del modello personalizzato
Prima di configurare la pipeline, dobbiamo scrivere il codice per il job di addestramento del modello personalizzato. Per addestrare il modello, utilizzeremo il set di dati Fagioli secchi di UCI Machine Learning, di KOKLU, M. e OZKAN, I.A., (2020), "Multiclass Classification of Dry Beans Using Computer Vision and Machine Learning Techniques", in Computers and Electronics in Agriculture, 174, 105507. DOI.
Il primo passaggio della pipeline creerà un set di dati gestito in Vertex AI utilizzando una tabella BigQuery contenente una versione di questi dati bean. Il set di dati verrà passato come input al nostro job di addestramento. Nel nostro codice di addestramento, avremo accesso alla variabile di ambiente per accedere a questo set di dati gestito.
Ecco come configureremo il job di addestramento personalizzato:
- Scrivi un modello Scikit-learn
DecisionTreeClassifierper classificare i tipi di fagioli nei nostri dati - Pacchettizzare il codice di addestramento in un container Docker ed eseguirne il push in Container Registry
Da qui, potremo avviare un job di addestramento Vertex AI direttamente dalla nostra pipeline. Iniziamo.
Passaggio 1: definisci il codice di addestramento in un container Docker
Nell'istanza di Notebooks, apri Avvio app e seleziona Terminale:
Quindi esegui quanto segue per configurare una directory in cui aggiungere il codice in container:
mkdir traincontainer
cd traincontainer
touch Dockerfile
mkdir trainer
touch trainer/train.py
Dopo aver eseguito questi comandi, dovresti vedere una directory denominata traincontainer/ creata a sinistra (per visualizzarla potrebbe essere necessario fare clic sull'icona di aggiornamento). Nella directory traincontainer/ vedrai quanto segue:
+ Dockerfile
+ trainer/
+ train.py
Il primo passaggio per containerizzare il codice è creare un Dockerfile. Nel nostro Dockerfile includeremo tutti i comandi necessari per eseguire l'immagine. Installerà tutte le librerie che utilizziamo e configurerà il punto di accesso per il nostro codice di addestramento. Apri il Dockerfile che hai appena creato e aggiungi quanto segue:
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"]
Per salvare i file durante la modifica nell'istanza del notebook, puoi utilizzare ctrl+s.
Quindi, apri il file train.py. Qui aggiungeremo il codice di addestramento. Copia quanto segue in train.py. Questo recupera i dati dal nostro set di dati gestito, li inserisce in un DataFrame Pandas, addestra un modello Scikit-learn e carica il modello addestrato su 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")
Quindi, torna al notebook ed esegui il seguente comando per sostituire YOUR_GCS_BUCKET nello script precedente con il nome del tuo 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
Se preferisci, puoi anche eseguire questa operazione manualmente. In questo caso, assicurati di non includere gs:// nel nome del bucket quando aggiorni lo script.
Ora il nostro codice di addestramento si trova in un contenitore Docker e siamo pronti per eseguire l'addestramento nel cloud.
Passaggio 2: esegui il push del container in Container Registry
Una volta completato il codice di addestramento, possiamo eseguire il push in Google Container Registry. In seguito, durante la configurazione del componente di addestramento della pipeline, punteremo le pipeline Vertex a questo container.
Torna al terminale e, dalla directory principale traincontainer/, definisci una variabile con l'URI dell'immagine container su Container Registry.
PROJECT_ID=$(gcloud config get-value project)
IMAGE_URI="gcr.io/$PROJECT_ID/scikit:v1"
Quindi, crea il container eseguendo quanto segue:
docker build ./ -t $IMAGE_URI
Infine, esegui il push del container in Container Registry:
docker push $IMAGE_URI
Vai alla sezione Container Registry della console Cloud per verificare che il contenitore sia presente. Ecco un esempio di come funziona:
6. Configurazione di un job di previsione batch
L'ultimo passaggio della nostra pipeline eseguirà un job di previsione batch. Affinché ciò funzioni, dobbiamo fornire un file CSV in Cloud Storage contenente gli esempi per i quali vogliamo ottenere le previsioni. Creeremo questo file CSV nel blocco note e lo copieremo in Cloud Storage utilizzando lo strumento a riga di comando gsutil.
Copiare esempi di previsione batch in Cloud Storage
Il seguente file contiene 3 esempi di ogni classe nel nostro set di dati di fagioli. L'esempio seguente non include la colonna Class, poiché è ciò che il nostro modello prevederà. Esegui il seguente comando per creare questo file CSV localmente nel tuo 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
Quindi, copia il file nel tuo bucket Cloud Storage:
!gsutil cp batch_examples.csv $BUCKET_NAME
Faremo riferimento a questo file nel passaggio successivo quando definiremo la pipeline.
7. Creazione di una pipeline con componenti predefiniti
Ora che il codice di addestramento è nel cloud, possiamo chiamarlo dalla nostra pipeline. La pipeline che definiremo utilizzerà tre componenti predefiniti della libreria google_cloud_pipeline_components che abbiamo installato in precedenza. Questi componenti predefiniti semplificano il codice che dobbiamo scrivere per configurare la pipeline e ci consentiranno di utilizzare i servizi Vertex AI come l'addestramento dei modelli e la previsione batch.
Ecco cosa farà la nostra pipeline in tre fasi:
- Creare un set di dati gestito in Vertex AI
- Esegui un job di addestramento su Vertex AI utilizzando il contenitore personalizzato che abbiamo configurato
- Esegui un job di previsione batch sul nostro modello di classificazione Scikit-learn addestrato
Passaggio 1: definisci la pipeline
Poiché utilizziamo componenti predefiniti, possiamo configurare l'intera pipeline nella definizione della pipeline. Aggiungi quanto segue a una cella del 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"
)
Passaggio 2: compila ed esegui la pipeline
Dopo aver definito la pipeline, puoi compilarla. Di seguito viene generato un file JSON che verrà utilizzato per eseguire la pipeline:
compiler.Compiler().compile(
pipeline_func=pipeline, package_path="custom_train_pipeline.json"
)
Poi, crea una variabile TIMESTAMP. Lo utilizzeremo nel nostro ID job:
from datetime import datetime
TIMESTAMP = datetime.now().strftime("%Y%m%d%H%M%S")
Poi definisci il job della pipeline, passando alcuni parametri specifici del progetto:
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,
)
Infine, esegui il job per creare una nuova esecuzione della pipeline:
pipeline_job.submit()
Dopo aver eseguito questa cella, dovresti vedere i log con un link per visualizzare l'esecuzione della pipeline nella console:
Vai al link. Puoi accedervi anche aprendo la dashboard delle pipeline. Al termine, la pipeline dovrebbe avere il seguente aspetto:
L'esecuzione di questa pipeline richiede 5-10 minuti, ma puoi passare al passaggio successivo prima del completamento. Di seguito scoprirai di più su cosa succede in ciascuno di questi passaggi della pipeline.
8. Informazioni sull'esecuzione della pipeline
Analizziamo più da vicino ciascuno dei tre passaggi della pipeline.
Passaggio 1 della pipeline: creazione di un set di dati gestito
Il primo passaggio nella pipeline crea un set di dati gestito in Vertex AI. Se fai clic sul seguente link al set di dati nella sezione Pipeline della console:
Vedrai il tuo set di dati in Vertex AI, che include un link all'origine dati in BigQuery, oltre alle informazioni sulle diverse colonne del set di dati. Dopo aver caricato un set di dati gestito in Vertex AI, puoi utilizzarlo per addestrare un modello AutoML o personalizzato.
Per i job di modelli personalizzati che utilizzano set di dati gestiti, Vertex AI passa variabili di ambiente speciali ai job di addestramento e gestisce la suddivisione dei dati in set di addestramento e test. Lo utilizzeremo nel prossimo passaggio della pipeline.
Passaggio 2 della pipeline: addestrare un modello in Vertex AI Training
Mentre il job di addestramento personalizzato è in esecuzione, puoi fare clic per visualizzare i log direttamente nella console Vertex Pipelines:
Puoi anche visualizzare i dettagli del job di addestramento personalizzato nella dashboard di addestramento di Vertex AI. Al termine del job di addestramento, in Vertex AI verrà creata una risorsa Model. Possiamo quindi eseguire il deployment di questo modello in un endpoint per le previsioni online o creare un job di previsione batch, che faremo nel passaggio successivo della pipeline.
Passaggio 3 della pipeline: esecuzione di un job di previsione batch sul nostro modello
Infine, la nostra pipeline riceverà le previsioni sugli esempi che abbiamo passato tramite un file CSV. Al termine del job di previsione in batch, Vertex AI scriverà un file CSV nella posizione specificata in Cloud Storage. Quando questo passaggio della pipeline inizia a essere eseguito, puoi andare alla sezione Predizioni batch della console Vertex AI per visualizzare il job creato.
Fai clic sul job al termine per visualizzare l'URL Cloud Storage delle previsioni batch:
Fai clic sul link per accedere alla directory Cloud Storage in cui puoi trovare i risultati della previsione, quindi fai clic per scaricare uno dei file prediction.results. Nel file dovresti vedere righe simili alle seguenti:
{"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"}
Sono inclusi i valori delle funzionalità per una determinata istanza, insieme alla classe prevista dal nostro modello. Per questo esempio, il nostro modello ritiene che si tratti di un bean "HOROZ".
Hai completato il lab.
🎉 Complimenti! 🎉
Hai imparato come utilizzare Vertex AI per:
- Utilizzare l'SDK Kubeflow Pipelines per creare pipeline end-to-end con componenti personalizzati
- Esegui le pipeline su Vertex Pipelines e avvia le esecuzioni della pipeline con l'SDK
- Visualizzare e analizzare il grafico di Vertex Pipelines nella console
- Utilizzare componenti della pipeline predefiniti per aggiungere servizi Vertex AI alla pipeline
- Pianificare job della pipeline ricorrenti
Per saperne di più sulle diverse parti di Vertex, consulta la documentazione.
9. Esegui la pulizia
Per evitare addebiti, ti consigliamo di eliminare le risorse create durante questo lab.
Passaggio 1: arresta o elimina l'istanza di Notebooks
Se vuoi continuare a utilizzare il blocco note creato in questo lab, ti consigliamo di disattivarlo quando non lo usi. Dall'interfaccia utente di Notebooks nella console Cloud, seleziona il blocco note, quindi seleziona Interrompi. Se vuoi eliminare completamente l'istanza, seleziona Elimina:
Passaggio 2: elimina il bucket Cloud Storage
Per eliminare il bucket di archiviazione, utilizza il menu di navigazione nella console Cloud, vai a Archiviazione, seleziona il bucket e fai clic su Elimina:
