1. Descripción general
En este lab, aprenderás a ejecutar un trabajo de entrenamiento de modelos personalizados con el SDK de Kubeflow Pipelines en Vertex Pipelines.
Qué aprenderá
Aprenderás a hacer lo siguiente:
- Aprenderás a usar el SDK de canalizaciones de Kubeflow para compilar canalizaciones de AA escalables.
- Crear y alojar en contenedores en un trabajo de entrenamiento de modelos personalizados de scikit-learn que usa conjuntos de datos administrados por Vertex AI y que se ejecutará en Vertex AI Training dentro de una canalización
- Ejecuta un trabajo de predicción por lotes en Vertex Pipelines
- Usa componentes predefinidos para interactuar con los servicios de Vertex AI que se proporcionan a través de la biblioteca
google_cloud_pipeline_components.
El costo total de la ejecución de este lab en Google Cloud es de aproximadamente $5.
2. Introducción a Vertex AI
En este lab, se usa Vertex AI, nuestra plataforma de AA administrada de extremo a extremo en Google Cloud. Vertex AI integra las ofertas de AA de Google en Google Cloud en una experiencia de desarrollo fluida. Además del entrenamiento de modelos y los servicios de implementación, Vertex AI también incluye una variedad de productos de MLOps, incluidos Vertex Pipelines (el producto en el que se enfoca este lab), Model Monitoring, Feature Store y mucho más. Puedes ver todas las ofertas de productos de Vertex AI en el diagrama que se muestra a continuación.
Si tienes comentarios, consulta la página de asistencia.
¿Por qué son útiles las canalizaciones de AA?
Antes de comenzar, primero debes comprender por qué deberías usar canalizaciones. Imagina que estás creando un flujo de trabajo de AA que incluye procesar datos, entrenar un modelo, ajustar hiperparámetros y realizar evaluaciones, así como implementar modelos. Es posible que cada uno de estos pasos tenga dependencias diferentes, lo que podría ser difícil de manejar si tratas todo el flujo de trabajo como una aplicación monolítica. A medida que empiezas a escalar tu proceso de AA, es posible que quieras compartir el flujo de trabajo de AA con otras personas de tu equipo para que puedan ejecutarlo y agregar más código. Pero esto puede ser complicado sin un proceso confiable y reproducible. Con las canalizaciones, cada paso en tu proceso de AA tiene su propio contenedor. Así, podrás desarrollar pasos de forma independiente y hacer un seguimiento de la entrada y salida en cada paso de manera reproducible. Además, puedes programar o activar ejecuciones para tu canalización en función de otros eventos de tu entorno de Cloud, como iniciar la ejecución de una canalización cuando hay nuevos datos de entrenamiento disponibles.
Resumen: Las canalizaciones te permiten agilizar y reproducir tus flujos de trabajo de AA.
3. Configura el entorno de Cloud
Para ejecutar este codelab, necesitarás un proyecto de Google Cloud Platform que tenga habilitada la facturación. Para crear un proyecto, sigue estas instrucciones.
Paso 1: Inicia Cloud Shell
En este lab, trabajarás con una sesión de Cloud Shell, que es un intérprete de comandos alojado en una máquina virtual que se ejecuta en la nube de Google. Podrías ejecutar fácilmente esta sección de forma local, en tu computadora, pero Cloud Shell brinda una experiencia reproducible en un entorno coherente para todo el mundo. Después de este lab, puedes volver a probar esta sección en tu computadora.
Activar Cloud Shell
En la parte superior derecha de la consola de Cloud, haz clic en el siguiente botón para activar Cloud Shell:
Si nunca iniciaste Cloud Shell, aparecerá una pantalla intermedia (mitad inferior de la página) que describe de qué se trata. Si ese es el caso, haz clic en Continuar (y no volverás a verlo). Así es como se ve la pantalla única:
El aprovisionamiento y la conexión a Cloud Shell solo tomará unos minutos.
Esta máquina virtual está cargada con todas las herramientas de desarrollo que necesitas. Ofrece un directorio principal persistente de 5 GB y se ejecuta en Google Cloud, lo que permite mejorar considerablemente el rendimiento de la red y la autenticación. Gran parte de tu trabajo en este codelab, si no todo, se puede hacer simplemente con un navegador o tu Chromebook.
Una vez conectado a Cloud Shell, debería ver que ya se autenticó y que el proyecto ya se configuró con tu ID del proyecto.
En Cloud Shell, ejecuta el siguiente comando para confirmar que tienes la autenticación:
gcloud auth list
Deberías ver algo como esto en el resultado del comando:
Ejecuta el siguiente comando en Cloud Shell para confirmar que el comando de gcloud conoce tu proyecto:
gcloud config list project
Resultado del comando
[core] project = <PROJECT_ID>
De lo contrario, puedes configurarlo con el siguiente comando:
gcloud config set project <PROJECT_ID>
Resultado del comando
Updated property [core/project].
Cloud Shell cuenta con algunas variables de entorno, incluida GOOGLE_CLOUD_PROJECT, que contiene el nombre de nuestro proyecto de Cloud actual. Lo usaremos en varios lugares a lo largo de este lab. Puede ejecutar el siguiente código para verla:
echo $GOOGLE_CLOUD_PROJECT
Paso 2: Habilitar las API
Más adelante, verás en qué momento se necesitan estos servicios y por qué. Por ahora, ejecuta este comando para que tu proyecto pueda acceder a los servicios de Compute Engine, Container Registry y Vertex AI:
gcloud services enable compute.googleapis.com \
containerregistry.googleapis.com \
aiplatform.googleapis.com
Si se realizó correctamente, se mostrará un mensaje similar a este:
Operation "operations/acf.cc11852d-40af-47ad-9d59-477a12847c9e" finished successfully.
Paso 3: Crea un bucket de Cloud Storage
Para ejecutar un trabajo de entrenamiento en Vertex AI, necesitaremos un bucket de almacenamiento para almacenar los elementos del modelo guardados. El bucket debe ser regional. Usaremos us-central aquí, pero puedes usar otra región (solo debes reemplazarla durante el lab). Si ya tiene un bucket, puede omitir este paso.
Ejecuta los siguientes comandos en la terminal de Cloud Shell para crear un bucket:
BUCKET_NAME=gs://$GOOGLE_CLOUD_PROJECT-bucket
gsutil mb -l us-central1 $BUCKET_NAME
A continuación, le daremos a la cuenta de servicio de Compute acceso a este bucket. Esto garantizará que Vertex Pipelines tenga los permisos necesarios para escribir archivos en el bucket. Ejecute el siguiente comando para agregar este permiso:
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
Paso 4: Crea una instancia de Vertex AI Workbench
En la sección Vertex AI de Cloud Console, haz clic en Workbench:
Allí, en Notebooks administrados por el usuario, haz clic en Nuevo notebook:
Luego, selecciona el tipo de instancia TensorFlow Enterprise 2.3 (with LTS) without GPUs:
Usa las opciones predeterminadas y, luego, haz clic en Crear.
Paso 5: Abre tu notebook
Una vez que se crea la instancia, selecciona Abrir JupyterLab:
4. Configuración de Vertex Pipelines
Existen algunas bibliotecas adicionales que debemos instalar para usar Vertex Pipelines:
- Kubeflow Pipelines: Este es el SDK que usaremos para compilar nuestra canalización. Vertex Pipelines admite canalizaciones en ejecución compiladas con Kubeflow Pipelines o TFX.
- Componentes de canalizaciones de Google Cloud: Esta biblioteca proporciona componentes predefinidos que facilitan la interacción con los servicios de Vertex AI durante los pasos de tu canalización.
Paso 1: Crea un notebook de Python y, luego, instala bibliotecas
Primero, en el menú Selector de tu instancia de notebook (a la que puedes acceder haciendo clic en el ícono + en la esquina superior izquierda del notebook), selecciona Python 3 para crear un notebook:
Para acceder al menú Selector, haz clic en Acceder + en la esquina superior izquierda de tu instancia de notebook.
Para instalar los dos servicios que usaremos en este lab, primero hay que establecer la marca de usuario en una celda del notebook:
USER_FLAG = "--user"
Luego, ejecuta el siguiente comando en tu 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
Luego de instalar estos paquetes, deberá reiniciar el 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)
Finalmente, verifique que instaló los paquetes de forma correcta. La versión del SDK de KFP debe ser igual o superior 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__))"
Paso 2: Configura tu ID del proyecto y bucket
Durante este lab, podrá hacer referencia al ID del proyecto de Cloud y al bucket que creó anteriormente. A continuación, crearemos variables para cada uno de ellos.
Si desconoce el ID de su proyecto, probablemente logre obtenerlo mediante la ejecución del siguiente 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)
De lo contrario, configúralo aquí:
if PROJECT_ID == "" or PROJECT_ID is None:
PROJECT_ID = "your-project-id" # @param {type:"string"}
Luego, cree una variable para almacenar el nombre de su bucket. Si lo creó en este lab, lo siguiente funcionará. De lo contrario, deberá configurarlo de forma manual:
BUCKET_NAME="gs://" + PROJECT_ID + "-bucket"
Paso 3: Importa bibliotecas
Agrega lo siguiente para importar las bibliotecas que usaremos durante este 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
Paso 4: Define las constantes
Lo último que debemos hacer antes de crear nuestra canalización es definir algunas variables constantes. PIPELINE_ROOT es la ruta de acceso de Cloud Storage en la que se escribirán los artefactos que cree nuestra canalización. Aquí estamos usando us-central1 como la región, pero si usaste una región diferente cuando creaste tu bucket, actualiza la variable REGION en el siguiente código:
PATH=%env PATH
%env PATH={PATH}:/home/jupyter/.local/bin
REGION="us-central1"
PIPELINE_ROOT = f"{BUCKET_NAME}/pipeline_root/"
PIPELINE_ROOT
Luego de ejecutar el código anterior, debería ver impreso el directorio raíz de su canalización. Esta es la ubicación de Cloud Storage en la que se escribirán los artefactos de su canalización, y tendrá el siguiente formato: gs://YOUR-BUCKET-NAME/pipeline_root/.
5. Configura un trabajo de entrenamiento de modelo personalizado
Antes de configurar nuestra canalización, debemos escribir el código para el trabajo de entrenamiento del modelo personalizado. Para entrenar el modelo, usaremos el conjunto de datos de frijoles secos de UCI Machine Learning de KOKLU, M. y OZKAN, I.A., (2020), "Multiclass Classification of Dry Beans Using Computer Vision and Machine Learning Techniques.""En Computers and Electronics in Agriculture, 174, 105507. DOI.
En el primer paso de la canalización, crearemos un conjunto de datos administrado en Vertex AI mediante una tabla de BigQuery que contiene una versión de estos datos de granos. El conjunto de datos se pasará como entrada a nuestro trabajo de entrenamiento. En nuestro código de entrenamiento, tendremos acceso a la variable de entorno para acceder a este conjunto de datos administrado.
Así es como configuraremos nuestro trabajo de entrenamiento personalizado:
- Escribir un modelo
DecisionTreeClassifierde scikit-learn para clasificar los tipos de granos en nuestros datos - Empaquetar el código de entrenamiento en un contenedor de Docker y enviarlo a Container Registry
A partir de ahí, podremos iniciar un trabajo de Vertex AI Training directamente desde nuestra canalización. Comencemos.
Paso 1: Define nuestro código de entrenamiento en un contenedor de Docker
En tu instancia de Notebooks, abre el Selector y selecciona Terminal:
Luego, ejecuta el siguiente comando para configurar un directorio en el que agregarás el código alojado en el contenedor:
mkdir traincontainer
cd traincontainer
touch Dockerfile
mkdir trainer
touch trainer/train.py
Después de ejecutar esos comandos, deberías ver un directorio llamado traincontainer/ creado a la izquierda (es posible que debas hacer clic en el ícono de actualizar para verlo). Verás lo siguiente en el directorio traincontainer/:
+ Dockerfile
+ trainer/
+ train.py
El primer paso para alojar el código en un contenedor es crear un Dockerfile. En nuestro Dockerfile, incluiremos todos los comandos necesarios para ejecutar la imagen. Así, se instalarán todas las bibliotecas que usemos y se configurará el punto de entrada para el código de entrenamiento. Abre el Dockerfile que acabas de crear y agrega lo siguiente:
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"]
Para guardar archivos a medida que los editas en tu instancia de notebook, puedes usar ctrl+s.
A continuación, abre el archivo train.py. Aquí es donde agregaremos nuestro código de entrenamiento. Copia lo siguiente en train.py: Esto recupera los datos de nuestro conjunto de datos administrado, los coloca en un DataFrame de Pandas, entrena un modelo de scikit-learn y sube el modelo entrenado a 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")
Luego, regresa a tu notebook y ejecuta el siguiente comando para reemplazar YOUR_GCS_BUCKET de la secuencia de comandos anterior por el nombre de tu bucket de 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
Si lo prefieres, también puedes hacerlo manualmente. Si lo haces, asegúrate de no incluir el gs:// en el nombre del bucket cuando actualices la secuencia de comandos.
Ahora el código de entrenamiento está en un contenedor de Docker y ya podemos ejecutar el entrenamiento en la nube.
Paso 2: Envía el contenedor a Container Registry
Con el código de entrenamiento completo, está todo listo para enviarlo a Google Container Registry. Más adelante, cuando configuremos el componente de entrenamiento de nuestra canalización, apuntaremos Vertex Pipelines a este contenedor.
Regresa a la terminal y, desde la raíz del directorio traincontainer/, define una variable con el URI para la imagen de contenedor en Container Registry.
PROJECT_ID=$(gcloud config get-value project)
IMAGE_URI="gcr.io/$PROJECT_ID/scikit:v1"
Luego, ejecuta el siguiente comando para compilar el contenedor:
docker build ./ -t $IMAGE_URI
Por último, envía el contenedor a Container Registry:
docker push $IMAGE_URI
Navega a la sección Container Registry de la consola de Cloud para verificar que el contenedor esté allí. Tendrá un aspecto similar a este:
6. Configura un trabajo de predicción por lotes
En el último paso de nuestra canalización, se ejecutará un trabajo de predicción por lotes. Para que esto funcione, debemos proporcionar un archivo CSV en Cloud Storage que contenga los ejemplos sobre los que queremos obtener predicciones. Crearemos este archivo CSV en nuestro notebook y lo copiaremos en Cloud Storage con la herramienta de línea de comandos de gsutil.
Copia los ejemplos de predicción por lotes en Cloud Storage
El siguiente archivo contiene 3 ejemplos de cada clase de nuestro conjunto de datos de granos. En el siguiente ejemplo, no se incluye la columna Class, ya que eso es lo que predecirá nuestro modelo. Ejecuta el siguiente comando para crear este archivo CSV de manera local en tu 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
Luego, copia el archivo a tu bucket de Cloud Storage:
!gsutil cp batch_examples.csv $BUCKET_NAME
Haremos referencia a este archivo en el siguiente paso cuando definamos nuestra canalización.
7. Compila una canalización con componentes compilados previamente
Ahora que el código de entrenamiento está en la nube, podemos llamarlo desde nuestra canalización. La canalización que definiremos usará tres componentes compilados previamente de la biblioteca google_cloud_pipeline_components que instalamos antes. Estos componentes predefinidos simplifican el código que debemos escribir para configurar nuestra canalización y nos permitirán usar los servicios de Vertex AI, como el entrenamiento de modelos y la predicción por lotes.
Esto es lo que hará nuestra canalización de tres pasos:
- Crea un conjunto de datos administrado en Vertex AI
- Ejecutar un trabajo de entrenamiento en Vertx AI con el contenedor personalizado que configuramos
- Ejecutar un trabajo de predicción por lotes en nuestro modelo de clasificación de scikit-learn entrenado
Paso 1: Define nuestra canalización
Debido a que usamos componentes previamente compilados, podemos configurar nuestra canalización completa en la definición de la canalización. Agrega el siguiente comando a una celda 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"
)
Paso 2: Compila y ejecuta la canalización
Luego de que definas la canalización, la podrás compilar. El siguiente comando generará un archivo JSON que utilizará para ejecutarla:
compiler.Compiler().compile(
pipeline_func=pipeline, package_path="custom_train_pipeline.json"
)
Luego, crea una variable TIMESTAMP. Lo usaremos en nuestro ID de trabajo:
from datetime import datetime
TIMESTAMP = datetime.now().strftime("%Y%m%d%H%M%S")
Luego, define tu trabajo de canalización y pasa algunos parámetros específicos del proyecto:
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,
)
Por último, ejecuta el trabajo para crear una ejecución de canalización nueva:
pipeline_job.submit()
Después de ejecutar esta celda, deberías ver registros con un vínculo para ver la ejecución de la canalización en tu consola:
Navega a ese vínculo. También puedes acceder a él si abres el panel de Pipelines. Tu canalización debería verse así cuando se complete:
Esta canalización demorará de 5 a 10 minutos en ejecutarse, pero puedes continuar con el siguiente paso antes de completarse. A continuación, obtendrás más información sobre lo que sucede en cada uno de estos pasos de canalización.
8. Comprende la ejecución de tu canalización
Analicemos con más detalle cada uno de los tres pasos de la canalización.
Paso 1 de la canalización: Crea un conjunto de datos administrado
El primer paso de nuestra canalización crea un conjunto de datos administrado en Vertex AI. Si haces clic en el siguiente vínculo del conjunto de datos en la sección Canalizaciones de tu consola:
Verás tu conjunto de datos en Vertex AI, que incluye un vínculo a la fuente de datos en BigQuery junto con información sobre las diferentes columnas de tu conjunto de datos. Una vez que hayas subido un conjunto de datos administrado a Vertex AI, se puede usar para entrenar un modelo de AutoML o personalizado.
En el caso de los trabajos de modelos personalizados que usan conjuntos de datos administrados, Vertex AI pasa variables de entorno especiales a tus trabajos de entrenamiento y se encarga de dividir tus datos en conjuntos de entrenamiento y prueba. Usaremos esto en el próximo paso de la canalización.
Paso 2 de la canalización: Entrena un modelo en Vertex AI Training
Mientras se ejecuta tu trabajo de entrenamiento personalizado, puedes hacer clic para ver los registros directamente en la consola de Vertex Pipelines:
También puedes ver los detalles en el trabajo de entrenamiento personalizado en tu panel de Vertex AI Training. Cuando se complete el trabajo de entrenamiento, se creará un recurso de modelo en Vertex AI. A continuación, podemos implementar este modelo en un extremo para realizar predicciones en línea o crear un trabajo de predicción por lotes, que haremos en el siguiente paso de la canalización.
Paso 3 de la canalización: Ejecuta un trabajo de predicción por lotes en nuestro modelo
Por último, nuestra canalización obtendrá predicciones sobre los ejemplos que pasamos a través de un archivo CSV. Cuando se complete el trabajo de predicción por lotes, Vertex AI escribirá un archivo CSV en la ubicación que especificamos en Cloud Storage. Cuando este paso de la canalización comience a ejecutarse, podrás navegar a la sección Predicciones por lotes de la consola de Vertex AI para ver el trabajo que se creó.
Haz clic en el trabajo cuando se complete para ver la URL de Cloud Storage de tus predicciones por lotes:
Haz clic en ese vínculo para ir al directorio de Cloud Storage en el que puedes encontrar los resultados de la predicción y, luego, haz clic para descargar uno de los archivos prediction.results. En el archivo, deberías ver filas que se ven de la siguiente manera:
{"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"}
Esto incluye los valores de atributos de una instancia en particular, junto con la clase que predijo nuestro modelo. Para este ejemplo, nuestro modelo cree que se trataba de un “HOROZ” por frijol.
Con eso, terminaste el lab.
🎉 ¡Felicitaciones! 🎉
Aprendiste a usar Vertex AI para hacer lo siguiente:
- Usar el SDK de Kubeflow Pipelines para compilar canalizaciones con componentes personalizados
- Ejecuta tus canalizaciones en Vertex Pipelines y, luego, inicia las ejecuciones de estas con el SDK
- Visualiza y analiza tu grafo de Vertex Pipelines en la consola
- Usar componentes de canalizaciones compilados previamente para agregar servicios de Vertex AI a tu canalización
- Programar trabajos de canalización recurrentes
Para obtener más información sobre las distintas partes de Vertex, consulte la documentación.
9. Limpieza
Para que no se te cobre, se recomienda borrar los recursos que creaste durante este lab.
Paso 1: Detén o borra la instancia de Notebooks
Si quieres continuar usando el notebook que creaste en este lab, te recomendamos que lo desactives cuando no lo utilices. En la IU de Notebooks de la consola de Cloud, selecciona el notebook y, luego, haz clic en Detener. Si quieres borrar la instancia por completo, selecciona Borrar (Delete):
Paso 2: Borra el bucket de Cloud Storage
Para borrar el bucket de almacenamiento, en el menú de navegación de la consola de Cloud, navega a Almacenamiento, selecciona tu bucket y haz clic en Borrar (Delete):
