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
Imparerai a:
- Utilizzare l'SDK Kubeflow Pipelines per creare pipeline ML scalabili
- Crea e containerizza un job di addestramento di modelli Scikit-learn personalizzato che utilizza set di dati gestiti da Vertex AI e che verrà eseguito su Vertex AI Training all'interno di una pipeline
- Esegui un job di previsione batch all'interno di 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.
Il comando tl;dr: le pipeline consentono di snellire e riprodurre i flussi di lavoro ML.
3. Configurazione dell'ambiente cloud
Per eseguire questo codelab, è necessario un progetto Google Cloud con 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, ti viene mostrata una schermata intermedia (below the fold) che descrive di cosa si tratta. In tal caso, fai clic su Continua (e non la vedrai più). Ecco come appare quella singola schermata:
Il provisioning e la connessione a Cloud Shell dovrebbero richiedere solo qualche istante.
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 di rete e l'autenticazione. Gran parte, se non tutto, del lavoro in questo codelab può essere svolto semplicemente con un browser o 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 comando dovrebbe essere simile al seguente:
Esegui questo comando in Cloud Shell per confermare che il comando gcloud è a conoscenza del 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 ha alcune variabili di ambiente, tra cui GOOGLE_CLOUD_PROJECT, che contiene il nome del nostro attuale progetto Cloud. 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, avremo 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 durante 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 daremo al nostro account di servizio Compute l'accesso a questo 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, all'interno dei Blocchi note gestiti dall'utente, fai clic su Nuovo blocco note:
Quindi seleziona il tipo di istanza TensorFlow Enterprise 2.3 (con LTS) senza GPU:
Utilizza le opzioni predefinite e 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: si tratta dell'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 blocco note Python e installa le librerie
Innanzitutto, dal menu Avvio app della tua istanza di blocco note (a cui puoi accedere facendo clic sull'icona + in alto a sinistra del blocco note), crea un blocco note selezionando Python 3:
Puoi accedere al menu Avvio app facendo clic sul segno + in alto a sinistra dell'istanza del blocco note.
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, è necessario 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 maggiore o uguale a 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
Durante questo lab, farai riferimento all'ID del progetto Cloud e al bucket che hai creato in precedenza. Ora creeremo le variabili per ciascuno di questi.
Se non conosci l'ID progetto, potresti riuscire a recuperarlo eseguendo il comando seguente:
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)
Altrimenti, impostala 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, funzionerà quanto segue. 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 artefatti creati dalla nostra pipeline. Qui stiamo utilizzando 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 località di Cloud Storage in cui verranno scritti gli artefatti della tua pipeline. Sarà nel formato gs://YOUR-BUCKET-NAME/pipeline_root/
5. Configurazione di un job di addestramento di modelli personalizzati
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 Secchi di UCI Machine Learning da: 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 nostro job di addestramento personalizzato:
- Scrivi un modello
DecisionTreeClassifierScikit-learn per 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 Vertex AI Training direttamente dalla nostra pipeline. Iniziamo.
Passaggio 1: definisci il codice di addestramento in un container Docker
Dalla tua istanza di Notebooks, apri Avvio app e seleziona Terminale:
Poi esegui questo comando per configurare una directory in cui aggiungerai il codice containerizzato:
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 (potrebbe essere necessario fare clic sull'icona di aggiornamento per visualizzarla). 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 stiamo utilizzando e configurerà il punto di ingresso per il nostro codice di addestramento. Apri il Dockerfile 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 mentre li modifichi nell'istanza del blocco note, puoi utilizzare ctrl+s.
Quindi, apri il file train.py. Qui aggiungeremo il codice di addestramento. Copia quanto segue in train.py. Questa operazione consente di recuperare i dati dal nostro set di dati gestito, li inserisce in un DataFrame Pandas, addestra un modello Scikit-learn e viene caricato 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 blocco note ed esegui il comando riportato di seguito per sostituire YOUR_GCS_BUCKET dello script riportato sopra 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 farlo manualmente. In questo caso, assicurati di non includere gs:// nel nome del bucket quando aggiorni lo script.
Ora il codice di addestramento si trova in un container 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 della directory 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 questo comando:
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 container sia presente. Ecco un esempio di come funziona:
6. Configurazione di un job di previsione batch
L'ultimo passaggio della pipeline eseguirà un job di previsione batch. Affinché questo comando funzioni, dobbiamo fornire un file CSV in Cloud Storage che contenga gli esempi per i quali vogliamo ottenere previsioni. Creeremo questo file CSV nel blocco note e lo copieremo in Cloud Storage utilizzando lo strumento a riga di comando gsutil.
Copia degli esempi di previsione batch in Cloud Storage
Il file seguente contiene 3 esempi per ciascuna classe del nostro set di dati beans. L'esempio seguente non include la colonna Class poiché questo è ciò che il nostro modello prevede. Per creare il file CSV in locale nel blocco note, esegui il comando riportato di seguito:
%%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 permetteranno di usare i servizi di Vertex AI come l'addestramento dei modelli e la previsione batch.
Ecco cosa farà la nostra pipeline in tre fasi:
- Crea un set di dati gestito in Vertex AI
- Esegui un job di addestramento su Vertx AI utilizzando il container personalizzato che abbiamo configurato
- Esegui un job di previsione batch sul nostro modello addestrato di classificazione Scikit-learn
Passaggio 1: definisci la pipeline
Poiché utilizziamo componenti predefiniti, possiamo impostare l'intera pipeline nella definizione della pipeline. Aggiungi quanto segue a una cella del blocco note:
@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 verrà generato un file JSON che utilizzerai per eseguire la pipeline:
compiler.Compiler().compile(
pipeline_func=pipeline, package_path="custom_train_pipeline.json"
)
A questo punto, crea una variabile TIMESTAMP. Utilizzeremo questo indirizzo nel nostro ID job:
from datetime import datetime
TIMESTAMP = datetime.now().strftime("%Y%m%d%H%M%S")
Quindi 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 a quel link. Puoi accedervi anche aprendo la dashboard delle pipeline. Al termine, la pipeline dovrebbe avere questo aspetto:
L'esecuzione di questa pipeline richiederà 5-10 minuti, ma puoi andare al passaggio successivo prima che venga completata. Ora scoprirai di più su cosa accade in ciascuno di questi passaggi della pipeline.
8. Comprensione dell'esecuzione della pipeline
Approfondiamo ciascun passaggio dei tre passaggi della pipeline.
Passaggio 1 della pipeline: crea 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 tua console:
Vedrai il tuo set di dati in Vertex AI, che include un link all'origine dati in BigQuery insieme alle informazioni sulle diverse colonne del set di dati. Una volta caricato su Vertex AI un set di dati gestito, 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 di modello. Possiamo quindi eseguire il deployment di questo modello su un endpoint per le previsioni online o creare un job di previsione batch, che eseguiremo nel prossimo passaggio della pipeline.
Passaggio 3 della pipeline: esecuzione di un job di previsione batch sul nostro modello
Infine, la nostra pipeline otterrà previsioni sugli esempi passati tramite un file CSV. Al termine del job di previsione batch, Vertex AI scriverà un file CSV nella località specificata in Cloud Storage. Quando viene avviata l'esecuzione di questo passaggio della pipeline, puoi andare alla sezione Previsioni batch della console Vertex AI per vedere il job creato.
Fai clic sul job una volta completato per visualizzare l'URL di 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 alla seguente:
{"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"}
Questo include i valori delle caratteristiche per una determinata istanza, insieme alla classe prevista dal nostro modello. Per questo esempio, il nostro modello ritiene che si trattasse di un "HOROZ" fagiolo.
Con questo, hai terminato 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
- Visualizza e analizza il grafico Vertex Pipelines nella console
- Usa i componenti predefiniti della pipeline per aggiungere servizi Vertex AI alla tua pipeline
- Pianifica job della pipeline ricorrenti
Per scoprire 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, utilizzando il menu di navigazione nella console Cloud, vai a Storage, seleziona il bucket e fai clic su Elimina:
