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
- Crea e inserisci in un contenitore un job di addestramento del modello Scikit-learn personalizzato che utilizza set di dati gestiti da Vertex AI e verrà eseguito su Vertex AI Training all'interno di una pipeline
- Esegui un job di previsioni in batch in Vertex Pipelines
- Utilizzare i componenti predefiniti per interagire con i servizi Vertex AI, forniti tramite la libreria
google_cloud_pipeline_components
Il costo totale per eseguire questo lab su Google Cloud è di circa 5$.
2. Introduzione a Vertex AI
Questo lab utilizza Vertex AI, la nostra piattaforma ML end-to-end gestita su Google Cloud. Vertex AI integra le offerte ML di Google in 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 workflow 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 tuoi workflow ML.
3. Configurazione dell'ambiente cloud
Per eseguire questo codelab, devi avere un progetto Google Cloud Platform 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 della console Cloud, fai clic sul pulsante seguente per attivare Cloud Shell:
Se non hai mai avviato Cloud Shell, viene visualizzata una schermata intermedia (sotto la piega) che ne descrive le funzionalità. In questo caso, fai clic su Continua e non comparirà più. Ecco come si presenta la schermata intermedia:
Bastano pochi istanti per eseguire il provisioning e connettersi a Cloud Shell.
Questa macchina virtuale è caricata con tutti gli strumenti per sviluppatori 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 del lavoro per questo codelab, se non tutto, può essere svolto semplicemente con un browser o con 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
Nell'output del comando dovresti visualizzare un risultato simile a questo:
Esegui questo 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. La 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 disporrà delle autorizzazioni necessarie per scrivere file nel 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
Nella sezione Vertex AI della console Cloud, fai clic su Workbench:
Da qui, in Blocchi note gestiti dall'utente, fai clic su Nuovo notebook:
Poi 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 notebook
Una volta creata l'istanza, seleziona Apri JupyterLab:
4. Configurazione di Vertex Pipelines
Per utilizzare Vertex Pipelines, devi installare alcune librerie aggiuntive:
- Kubeflow Pipelines: questo è l'SDK che utilizzeremo per creare la pipeline. Vertex Pipelines supporta l'esecuzione di pipeline create con Kubeflow Pipelines o TFX.
- Google Cloud Pipeline Components: 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 app nell'istanza 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 nell'istanza del blocco note.
Per installare entrambi i servizi che utilizzeremo in questo lab, imposta prima il flag utente in una cella del notebook:
USER_FLAG = "--user"
Poi esegui questo codice dal 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
Dopo aver installato questi pacchetti, devi 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 uguale o superiore alla 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 progetto Cloud e al bucket che hai creato in precedenza. Poi creeremo le variabili per ciascuno di questi.
Se non conosci l'ID progetto, potresti recuperarlo eseguendo questo comando:
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"}
Adesso crea una variabile per archiviare il nome del bucket. Se l'hai creato in questo lab, funzionerà quanto segue. In caso contrario, dovrai impostarlo 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 da fare prima di creare la pipeline è definire alcune variabili delle costanti. PIPELINE_ROOT è il percorso Cloud Storage in cui verranno scritti gli artefatti creati dalla 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 riportato di seguito:
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 in alto, dovresti visualizzare la directory principale della pipeline. Questa è la posizione di Cloud Storage in cui verranno scritti gli artefatti della pipeline. Sarà nel formato 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 UCI Machine Learning Dry Beans 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 sui fagioli. 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 Scikit-learn
DecisionTreeClassifierper classificare i tipi di fagioli nei nostri dati - Pacchettizza il codice di addestramento in un container Docker e invialo a 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
Dall'istanza Notebooks, apri Avvio app e seleziona Terminale:
Quindi, esegui questo comando per configurare una directory in cui aggiungerai il codice in contenitori:
mkdir traincontainer
cd traincontainer
touch Dockerfile
mkdir trainer
touch trainer/train.py
Dopo aver eseguito questi comandi, dovresti visualizzare una directory denominata traincontainer/ creata a sinistra (potresti dover 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 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 mentre li modifichi nell'istanza del notebook, puoi utilizzare ctrl+s.
Successivamente, apri il file train.py. È qui che aggiungeremo il nostro codice di addestramento. Copia quanto segue in train.py. 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 in 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")
Poi, torna al notebook ed esegui il comando seguente 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 farlo 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 container Docker e siamo pronti per eseguire l'addestramento nel cloud.
Passaggio 2: esegui il push del container in Container Registry
Ora che il codice di addestramento è completo, possiamo eseguirne il push in Google Container Registry. In seguito, quando configureremo il componente di addestramento della pipeline, indirizzeremo Vertex Pipelines a questo container.
Torna al terminale e, dalla radice della directory traincontainer/, definisci una variabile con l'URI dell'immagine container in 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 previsioni in batch
L'ultimo passaggio della pipeline eseguirà un job di previsioni in batch. Per fare in modo che funzioni, dobbiamo fornire un file CSV in Cloud Storage che contenga gli esempi per cui vogliamo ottenere le previsioni. Creeremo questo file CSV nel nostro notebook e lo copieremo in Cloud Storage utilizzando lo strumento a riga di comando gsutil.
Copia degli esempi di previsioni in batch in Cloud Storage
Il seguente file contiene tre esempi di ogni classe nel nostro set di dati sui fagioli. L'esempio riportato di seguito non include la colonna Class, poiché è ciò che il modello prevede. Esegui il comando seguente per creare questo file CSV localmente nel 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 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 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 consentono di utilizzare i servizi Vertex AI come l'addestramento del modello e le previsioni in batch.
Ecco cosa farà la nostra pipeline in tre passaggi:
- Crea un set di dati gestito in Vertex AI
- Esegui un job di addestramento su Vertex AI utilizzando il container personalizzato che abbiamo configurato
- Esegui un job di previsioni in batch sul 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
Una volta definita la pipeline, puoi compilarla. Il seguente comando genererà 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. 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 visualizzare i log con un link per visualizzare l'esecuzione della pipeline nella console:
Vai a questo link. Puoi accedervi anche aprendo la dashboard delle pipeline. Al termine, la pipeline dovrebbe avere l'aspetto seguente:
L'esecuzione di questa pipeline richiede 5-10 minuti, ma puoi passare al passaggio successivo prima che venga completata. Successivamente, scoprirai di più su cosa succede in ciascuno di questi passaggi della pipeline.
8. Informazioni sull'esecuzione della pipeline
Analizziamo più nel dettaglio ciascuno dei tre passaggi della pipeline.
Passaggio 1 della pipeline: crea un set di dati gestito
Il primo passaggio della 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 e informazioni sulle diverse colonne del set di dati. Una volta caricato un set di dati gestito su Vertex AI, può essere utilizzato 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 passaggio successivo della pipeline.
Passaggio 2 della pipeline: addestramento di 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 Training 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 previsioni in batch, che eseguiremo nel passaggio successivo della pipeline.
Passaggio 3 della pipeline: esecuzione di un job di previsioni in batch sul nostro modello
Infine, la pipeline otterrà le previsioni sugli esempi che abbiamo inserito tramite un file CSV. Al termine del job di previsioni in batch, Vertex AI scrive un file CSV nella posizione specificata in Cloud Storage. Quando questo passaggio della pipeline inizia a essere eseguito, puoi andare alla sezione Previsioni 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 andare 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 caratteristiche per una determinata istanza, insieme alla classe prevista dal modello. Per questo esempio, il nostro modello ritiene che si tratti di un fagiolo "HOROZ".
Con questo, hai completato il lab.
🎉 Congratulazioni! 🎉
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 delle pipeline con l'SDK
- Visualizzare e analizzare il grafico di Vertex Pipelines nella console
- Utilizzare i componenti della pipeline predefiniti per aggiungere i 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 Google Cloud, vai a Storage, seleziona il bucket e fai clic su Elimina:
