GSP965

Descripción general

Las canalizaciones te permiten automatizar y reproducir tu flujo de trabajo de AA. Vertex AI integra las ofertas de AA de Google Cloud en una experiencia de desarrollo fluida. Anteriormente, se podía acceder a los modelos personalizados y a los entrenados con AutoML mediante servicios independientes. Vertex AI combina ambos en una sola API, junto con otros productos nuevos. Además, Vertex AI también incluye una variedad de productos de MLOps, como Vertex Pipelines. En este lab, aprenderás a crear y ejecutar canalizaciones de AA con Vertex Pipelines.

¿Por qué son útiles las canalizaciones de AA?

Antes de comenzar, primero debes comprender por qué deberías utilizar canalizaciones. Imagina que estás compilando un flujo de trabajo de AA que incluye procesar datos, implementar y entrenar modelos, ajustar hiperparámetros y realizar evaluaciones. 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. De esta forma, 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 cuando hay nuevos datos de entrenamiento disponibles.

Objetivos

En este lab, aprenderás a realizar las siguientes tareas:

• Usar el SDK de canalizaciones de Kubeflow para compilar canalizaciones de AA escalables
• Aprenderás a crear y ejecutar una canalización de introducción en 3 pasos que admite entradas de texto.
• Aprenderás a crear y ejecutar una canalización que entrene, evalúe y, luego, implemente un modelo de clasificación de AutoML.
• Aprenderás a usar componentes predefinidos para interactuar con los servicios de Vertex AI que se proporcionan mediante la biblioteca google_cloud_pipeline_components.
• Aprenderás a programar un trabajo de canalización con Cloud Scheduler.

Configuración y requisitos

Antes de hacer clic en el botón Comenzar lab

Lee estas instrucciones. Los labs son cronometrados y no se pueden pausar. El cronómetro, que comienza a funcionar cuando haces clic en Comenzar lab, indica por cuánto tiempo tendrás a tu disposición los recursos de Google Cloud.

Este lab práctico te permitirá realizar las actividades correspondientes en un entorno de nube real, no en uno de simulación o demostración. Para ello, se te proporcionan credenciales temporales nuevas que utilizarás para acceder a Google Cloud durante todo el lab.

Para completar este lab, necesitarás lo siguiente:

• Acceso a un navegador de Internet estándar (se recomienda el navegador Chrome)

Nota: Usa una ventana de navegador privada o de Incógnito para ejecutar este lab. Así evitarás cualquier conflicto entre tu cuenta personal y la cuenta de estudiante, lo que podría generar cargos adicionales en tu cuenta personal.

• Tiempo para completar el lab: Recuerda que, una vez que comienzas un lab, no puedes pausarlo.

Nota: Si ya tienes un proyecto o una cuenta personal de Google Cloud, no los uses en este lab para evitar cargos adicionales en tu cuenta.

Cómo iniciar tu lab y acceder a la consola de Google Cloud

1. Haga clic en el botón Comenzar lab. Si debe pagar por el lab, se abrirá una ventana emergente para que seleccione su forma de pago. A la izquierda, se encuentra el panel Detalles del lab, que tiene estos elementos:

   • El botón Abrir la consola de Google Cloud
   • El tiempo restante
   • Las credenciales temporales que debe usar para el lab
   • Otra información para completar el lab, si es necesaria

2. Haz clic en Abrir la consola de Google Cloud (o haz clic con el botón derecho y selecciona Abrir el vínculo en una ventana de incógnito si ejecutas el navegador Chrome).

   El lab inicia recursos y abre otra pestaña en la que se muestra la página de acceso.

   Sugerencia: Ordene las pestañas en ventanas separadas, una junto a la otra.

   Nota: Si ves el diálogo Elegir una cuenta, haz clic en Usar otra cuenta.

3. De ser necesario, copia el nombre de usuario a continuación y pégalo en el diálogo Acceder.

   {{{user_0.username | "Username"}}}

   También puedes encontrar el nombre de usuario en el panel Detalles del lab.

4. Haz clic en Siguiente.

5. Copia la contraseña que aparece a continuación y pégala en el diálogo Te damos la bienvenida.

   {{{user_0.password | "Password"}}}

   También puedes encontrar la contraseña en el panel Detalles del lab.

6. Haz clic en Siguiente.

   Importante: Debes usar las credenciales que te proporciona el lab. No uses las credenciales de tu cuenta de Google Cloud. Nota: Usar tu propia Cuenta de Google podría generar cargos adicionales.

7. Haga clic para avanzar por las páginas siguientes:

   • Acepta los Términos y Condiciones.
   • No agregues opciones de recuperación o autenticación de dos factores (esta es una cuenta temporal).
   • No te registres para obtener pruebas gratuitas.

Después de un momento, se abrirá la consola de Google Cloud en esta pestaña.

Nota: Para ver un menú con una lista de productos y servicios de Google Cloud, haz clic en el menú de navegación que se encuentra en la parte superior izquierda.

Tarea 1: Crea una instancia de notebooks de Vertex

1. Haz clic en Menú de navegación.

2. Navega a Vertex AI y selecciona Workbench.

3. En la página Instancias de notebook, navega a la pestaña Notebooks administrados por el usuario y espera hasta que ai-notebook se cree por completo.

Nota: La creación completa del notebook debería tardar unos minutos.

4. Una vez que se crea la instancia, selecciona Abrir JupyterLab:

Verificar si se creó el notebook

Tarea 2: Configuración de Vertex Pipelines

Existen algunas bibliotecas adicionales que deberás instalar para usar Vertex Pipelines:

• Kubeflow Pipelines: Este es el SDK que se usa para compilar la 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

1. En el menú Selector de tu instancia de notebook, selecciona Python 3 para crear un notebook:

2. Para acceder al menú Selector, haz clic en Acceder + en la esquina superior izquierda de tu instancia de notebook.

3. Para instalar los servicios que necesitas para este lab, primero configura la marca de usuario en una celda de notebook:

USER_FLAG = "--user"

4. Luego, ejecuta el siguiente comando en tu notebook:

!pip3 install {USER_FLAG} google-cloud-aiplatform==1.0.0 --upgrade !pip3 install {USER_FLAG} kfp google-cloud-pipeline-components==0.1.1 --upgrade !pip3 install -U google-cloud-aiplatform !pip3 uninstall -y shapely pygeos geopandas !pip3 install shapely==1.8.5.post1 pygeos==0.12.0 geopandas==0.10.2 !pip3 install google-cloud-pipeline-components Nota: Verás advertencias y errores relacionados con las versiones, que puedes ignorar de forma segura.

5. Luego de instalar estos paquetes, deberás 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)

6. Finalmente, verifica que instalaste los paquetes de forma correcta. La versión del SDK de KFP debe ser igual o superior a 1.6:

!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ás hacer referencia al ID del proyecto de Cloud y al bucket que creaste anteriormente. Luego, crearás variables para cada uno de ellos.

1. Si desconoces el ID de tu proyecto, probablemente logres obtenerlo por medio de 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)

2. Luego, crea una variable para almacenar el nombre de tu bucket.

BUCKET_NAME="gs://" + PROJECT_ID + "-bucket"

Paso 3: Importa bibliotecas

• Agrega la siguiente información para importar las bibliotecas que utilizarás durante este lab:

from typing import NamedTuple import kfp from kfp import dsl from kfp.v2 import compiler from kfp.v2.dsl import (Artifact, Dataset, Input, InputPath, Model, Output, OutputPath, ClassificationMetrics, Metrics, component) from kfp.v2.google.client import AIPlatformClient from google.cloud import aiplatform from google_cloud_pipeline_components import aiplatform as gcc_aip

Paso 4: Define las constantes

• Lo último que debes hacer antes de compilar la canalización es definir algunas variables constantes. PIPELINE_ROOT es la ruta de Cloud Storage en la que se escribirán los artefactos que cree tu canalización. Aquí estás usando la región . Sin embargo, si usaste una region 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="{{{ project_0.default_region | Placeholder value. }}}" PIPELINE_ROOT = f"{BUCKET_NAME}/pipeline_root/" PIPELINE_ROOT

Luego de ejecutar el código anterior, deberías ver impreso el directorio raíz de tu canalización. Esta es la ubicación de Cloud Storage en la que se escribirán los artefactos de tu canalización, y tendrá el formato gs://<bucket_name>/pipeline_root/.

Tarea 3: Crea tu primera canalización

• Crea una canalización corta con el SDK de KFP. Esta canalización no ejecuta ninguna acción relacionada con el AA (no te preocupes, ya llegaremos a ese paso). Mediante este ejercicio, buscamos que aprendas los siguientes procesos:

  • Cómo crear componentes personalizados en el SDK de KFP
  • Cómo ejecutar y supervisar una canalización en Vertex Pipelines

Crearás una canalización que imprima una oración mediante dos salidas: el nombre de un producto y una descripción en forma de emoji. Esta canalización consistirá en tres componentes:

• product_name: Este componente tomará un nombre de producto como entrada y mostrará esa cadena como salida.
• emoji: Este componente tomará la descripción de texto de un emoji y lo convertirá en un emoji. Por ejemplo, el código de texto para ✨ es “sparkles”. Este componente utiliza una biblioteca de emojis para mostrarte cómo administrar dependencias externas en tu canalización.
• build_sentence: Este componente final consumirá la salida de los dos componentes anteriores para crear una oración que utilice el emoji. Por ejemplo, la salida sería “Vertex Pipelines es ✨”.

Paso 1: Crea un componente basado en una función de Python

Con el SDK de KFP, puedes crear componentes basados en las funciones de Python. Primero crea el componente product_name, que simplemente toma una cadena como entrada y la muestra.

• Agrega el siguiente comando a tu notebook:

@component(base_image="python:3.9", output_component_file="first-component.yaml") def product_name(text: str) -> str: return text

Analiza con mayor detalle esta sintaxis:

• El decorador @component compila esta función en un componente cuando se ejecuta la canalización. Lo utilizarás cada vez que escribas un componente personalizado.
• El parámetro base_image especifica la imagen de contenedor que usará este componente.
• El parámetro output_component_file es opcional y especifica el archivo yaml en el que se escribirá el componente compilado. Luego de ejecutar la celda, deberías ver que ese archivo se escribió en tu instancia de notebook. Si quieres compartir este componente con otra persona, puedes enviar el archivo yaml generado para que lo cargue con el siguiente comando:

product_name_component = kfp.components.load_component_from_file('./first-component.yaml')

El segmento -> str que aparece después de la definición de la función especifica el tipo de resultado de este componente.

Paso 2: Crea dos componentes adicionales

1. Crea dos componentes adicionales para completar la canalización. El primero toma una cadena como entrada y la convierte en su emoji correspondiente, si es que tiene alguno. De esta forma, devolverá una tupla con el texto de entrada proporcionado, y el emoji resultante:

@component(base_image="python:3.9", output_component_file="second-component.yaml", packages_to_install=["emoji"]) def emoji( text: str, ) -> NamedTuple( "Outputs", [ ("emoji_text", str), # Return parameters ("emoji", str), ], ): import emoji emoji_text = text emoji_str = emoji.emojize(':' + emoji_text + ':', language='alias') print("output one: {}; output_two: {}".format(emoji_text, emoji_str)) return (emoji_text, emoji_str)

Este componente es un poco más complejo que el anterior. Aquí te mostramos lo nuevo:

• El parámetro packages_to_install indica al componente si hay dependencias de bibliotecas externas para tu contenedor. En este caso, usarás una biblioteca llamada emoji.
• Este componente muestra un NamedTuple llamado Outputs. Ten en cuenta que cada cadena de esta tupla tiene claves: emoji_text y emoji. Deberás utilizar estas claves en el próximo componente para acceder al resultado.

2. El componente final de esta canalización consumirá el resultado de las dos primeras y los combinará para devolver una cadena:

@component(base_image="python:3.9", output_component_file="third-component.yaml") def build_sentence( product: str, emoji: str, emojitext: str ) -> str: print("We completed the pipeline, hooray!") end_str = product + " is " if len(emoji) > 0: end_str += emoji else: end_str += emojitext return(end_str)

Quizás te estés preguntando, ¿cómo sabe este componente que debe utilizar el resultado de los pasos anteriores que definió?

Buena pregunta. Te darás cuenta en el próximo paso.

Paso 3: Junta los componentes en una canalización

Las definiciones indicadas de los componentes crearon funciones de fábrica que se pueden utilizar en una definición de canalización para crear pasos.

1. A fin de configurar una canalización, utiliza el decorador @dsl.pipeline, asigna un nombre y una descripción a la canalización y proporciona la ruta raíz en la que se deben escribir los artefactos de tu canalización. Los artefactos hacen referencia a los archivos de salida que genera tu canalización. Si bien esta canalización de introducción no genera ninguno, la siguiente lo hará.

2. En el siguiente bloque de códigos, define una función intro_pipeline. En este punto, especifica las entradas de los pasos iniciales de tu canalización, y cómo estos pasos se conectan entre sí:

• product_task toma el nombre de un producto como entrada. Aquí transfiere canalizaciones de “Vertex Pipelines”, pero puede cambiar esta configuración según tus necesidades.
• emoji_task toma el código de texto de un emoji como entrada. También puedes cambiarlo según tus necesidades. Por ejemplo, “party_face” hace referencia al emoji 🥳. Ten en cuenta que, como ni este ni el componente product_task tienen pasos que les otorguen entradas, debes especificarlas de forma manual cuando definas la canalización.
• El último paso de la canalización, consumer_task, tiene tres parámetros de entrada:
  • El resultado de product_task. Dado que en este paso solo se produce un resultado, puedes hacer referencia a él mediante product_task.output.
  • El resultado de emoji del paso emoji_task. Consulta el componente de emoji que se definió previamente en el que mencionaste los parámetros del resultado.
  • De forma similar, el resultado llamado emoji_text del componente emoji. En caso de que a tu canalización se le transfiera texto que no corresponde con el emoji, lo utilizarás para construir una oración.

@dsl.pipeline( name="hello-world", description="An intro pipeline", pipeline_root=PIPELINE_ROOT, ) # You can change the `text` and `emoji_str` parameters here to update the pipeline output def intro_pipeline(text: str = "Vertex Pipelines", emoji_str: str = "sparkles"): product_task = product_name(text) emoji_task = emoji(emoji_str) consumer_task = build_sentence( product_task.output, emoji_task.outputs["emoji"], emoji_task.outputs["emoji_text"], )

Paso 4: Compila y ejecuta la canalización

1. Luego de que definas la canalización, la podrás compilar. El siguiente comando generará un archivo JSON que utilizarás para ejecutarla:

compiler.Compiler().compile( pipeline_func=intro_pipeline, package_path="intro_pipeline_job.json" )

2. Luego, crea una instancia de un cliente de API:

api_client = AIPlatformClient( project_id=PROJECT_ID, region=REGION, )

3. Finalmente, ejecuta la canalización:

response = api_client.create_run_from_job_spec( job_spec_path="intro_pipeline_job.json", # pipeline_root=PIPELINE_ROOT # this argument is necessary if you did not specify PIPELINE_ROOT as part of the pipeline definition. )

Cuando ejecutes la canalización, se debería generar un vínculo para verla en tu consola. Se debería visualizar de la siguiente manera cuando se complete:

4. Esta canalización demorará de 5 a 6 minutos en ejecutarse. Cuando se complete, puedes hacer clic en el componente build-sentence para ver el resultado final:

Ahora que sabes cómo funcionan el SDK de KFP y Vertex Pipelines, ya puedes compilar una canalización que cree y, luego, implemente un modelo de AA con otros servicios de Vertex AI.

Verificar si se completó la canalización de tu emoji

Tarea 4: Crea una canalización de AA de extremo a extremo

Llegó la hora de compilar tu primera canalización de AA. En esta canalización, usarás el conjunto de datos de UCI Machine Learning Dry Beans 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.

Nota: Esta canalización demorará más de 2 horas en completarse. Por lo que no es necesario que esperes a que se complete la canalización para terminar el lab. Sigue los pasos hasta que el trabajo de canalización comience.

Este es un conjunto de datos tabular y tu canalización lo utilizará para entrenar, evaluar y, luego, implementar un modelo de AutoML que clasifique beans en uno de 7 tipos, según sus características.

Con esta canalización podrás realizar las siguientes acciones:

• Crear un conjunto de datos en Vertex AI
• Entrenar un modelo de clasificación tabular con AutoML
• Obtener métricas de evaluación sobre este modelo
• Según las métricas de evaluación, decidir si quieres implementar el modelo mediante una lógica condicional en Vertex Pipelines
• Implementar el modelo en un extremo mediante Vertex Prediction

Cada paso descrito será un componente. La mayoría de los pasos de la canalización usarán componentes predefinidos para los servicios de Vertex AI desde la biblioteca google_cloud_pipeline_components que importaste previamente en este lab.

En esta sección, primero definiremos un componente personalizado. Luego, definiremos el resto de los pasos de la canalización mediante componentes predefinidos. Estos componentes facilitan el acceso a los servicios de Vertex AI, como el entrenamiento y la implementación de modelos.

En este paso, la mayor parte del tiempo se dedicará a la pieza de entrenamiento de AutoML de esta canalización, que demorará aproximadamente una hora.

Paso 1: Un componente personalizado para la evaluación de modelos

El componente personalizado que definas se utilizará al final de la canalización, una vez que se complete el entrenamiento de modelos. Este componente realizará algunas acciones:

• Obtener las métricas de evaluación del modelo de clasificación entrenado de AutoML
• Analizar las métricas y renderizarlas en la IU de Vertex Pipelines
• Comparar las métricas con un umbral para determinar si se debe implementar el modelo

Antes de definir el componente, comprende sus parámetros de entrada y salida. Como entrada, esta canalización toma algunos metadatos sobre tu proyecto de Cloud, el modelo entrenado resultante (más adelante definirás este componente), las métricas de evaluación del modelo y un thresholds_dict_str.

El thresholds_dict_str lo definirás cuando ejecutes tu canalización. En el caso de este modelo de clasificación, será el valor del área bajo la curva ROC para el que debes implementar el modelo. Por ejemplo, si ingresas 0.95, significa que solo quieres que tu canalización implemente el modelo si esta métrica es superior al 95%.

El componente de evaluación devuelve una cadena que te indica si implementar el modelo o no hacerlo.

• Agrega el siguiente comando a una celda de notebook para crear este componente personalizado:

@component( base_image="gcr.io/deeplearning-platform-release/tf2-cpu.2-3:latest", output_component_file="tables_eval_component.yaml", # Optional: you can use this to load the component later packages_to_install=["google-cloud-aiplatform"], ) def classif_model_eval_metrics( project: str, location: str, # "region", api_endpoint: str, # "region-aiplatform.googleapis.com", thresholds_dict_str: str, model: Input[Model], metrics: Output[Metrics], metricsc: Output[ClassificationMetrics], ) -> NamedTuple("Outputs", [("dep_decision", str)]): # Return parameter. """This function renders evaluation metrics for an AutoML Tabular classification model. It retrieves the classification model evaluation generated by the AutoML Tabular training process, does some parsing, and uses that info to render the ROC curve and confusion matrix for the model. It also uses given metrics threshold information and compares that to the evaluation results to determine whether the model is sufficiently accurate to deploy. """ import json import logging from google.cloud import aiplatform # Fetch model eval info def get_eval_info(client, model_name): from google.protobuf.json_format import MessageToDict response = client.list_model_evaluations(parent=model_name) metrics_list = [] metrics_string_list = [] for evaluation in response: print("model_evaluation") print(" name:", evaluation.name) print(" metrics_schema_uri:", evaluation.metrics_schema_uri) metrics = MessageToDict(evaluation._pb.metrics) for metric in metrics.keys(): logging.info("metric: %s, value: %s", metric, metrics[metric]) metrics_str = json.dumps(metrics) metrics_list.append(metrics) metrics_string_list.append(metrics_str) return ( evaluation.name, metrics_list, metrics_string_list, ) # Use the given metrics threshold(s) to determine whether the model is # accurate enough to deploy. def classification_thresholds_check(metrics_dict, thresholds_dict): for k, v in thresholds_dict.items(): logging.info("k {}, v {}".format(k, v)) if k in ["auRoc", "auPrc"]: # higher is better if metrics_dict[k] < v: # if under threshold, don't deploy logging.info( "{} < {}; returning False".format(metrics_dict[k], v) ) return False logging.info("threshold checks passed.") return True def log_metrics(metrics_list, metricsc): test_confusion_matrix = metrics_list[0]["confusionMatrix"] logging.info("rows: %s", test_confusion_matrix["rows"]) # log the ROC curve fpr = [] tpr = [] thresholds = [] for item in metrics_list[0]["confidenceMetrics"]: fpr.append(item.get("falsePositiveRate", 0.0)) tpr.append(item.get("recall", 0.0)) thresholds.append(item.get("confidenceThreshold", 0.0)) print(f"fpr: {fpr}") print(f"tpr: {tpr}") print(f"thresholds: {thresholds}") metricsc.log_roc_curve(fpr, tpr, thresholds) # log the confusion matrix annotations = [] for item in test_confusion_matrix["annotationSpecs"]: annotations.append(item["displayName"]) logging.info("confusion matrix annotations: %s", annotations) metricsc.log_confusion_matrix( annotations, test_confusion_matrix["rows"], ) # log textual metrics info as well for metric in metrics_list[0].keys(): if metric != "confidenceMetrics": val_string = json.dumps(metrics_list[0][metric]) metrics.log_metric(metric, val_string) # metrics.metadata["model_type"] = "AutoML Tabular classification" logging.getLogger().setLevel(logging.INFO) aiplatform.init(project=project) # extract the model resource name from the input Model Artifact model_resource_path = model.uri.replace("aiplatform://v1/", "") logging.info("model path: %s", model_resource_path) client_options = {"api_endpoint": api_endpoint} # Initialize client that will be used to create and send requests. client = aiplatform.gapic.ModelServiceClient(client_options=client_options) eval_name, metrics_list, metrics_str_list = get_eval_info( client, model_resource_path ) logging.info("got evaluation name: %s", eval_name) logging.info("got metrics list: %s", metrics_list) log_metrics(metrics_list, metricsc) thresholds_dict = json.loads(thresholds_dict_str) deploy = classification_thresholds_check(metrics_list[0], thresholds_dict) if deploy: dep_decision = "true" else: dep_decision = "false" logging.info("deployment decision is %s", dep_decision) return (dep_decision,)

Paso 2: Agrega componentes predefinidos de Google Cloud

En este paso, definirás el resto de componentes de tu canalización y descubrirás cómo funcionan todos juntos.

1. Primero, define el nombre visible de la ejecución de tu canalización con una marca de tiempo:

import time DISPLAY_NAME = 'automl-beans{}'.format(str(int(time.time()))) print(DISPLAY_NAME)

2. Luego, copia el siguiente comando en una celda de notebook nueva:

@kfp.dsl.pipeline(name="automl-tab-beans-training-v2", pipeline_root=PIPELINE_ROOT) def pipeline( bq_source: str = "bq://aju-dev-demos.beans.beans1", display_name: str = DISPLAY_NAME, project: str = PROJECT_ID, gcp_region: str = "{{{ project_0.default_region | Placeholder value. }}}", api_endpoint: str = "{{{ project_0.default_region | Placeholder value. }}}-aiplatform.googleapis.com", thresholds_dict_str: str = '{"auRoc": 0.95}', ): dataset_create_op = gcc_aip.TabularDatasetCreateOp( project=project, display_name=display_name, bq_source=bq_source ) training_op = gcc_aip.AutoMLTabularTrainingJobRunOp( project=project, display_name=display_name, optimization_prediction_type="classification", budget_milli_node_hours=1000, column_transformations=[ {"numeric": {"column_name": "Area"}}, {"numeric": {"column_name": "Perimeter"}}, {"numeric": {"column_name": "MajorAxisLength"}}, {"numeric": {"column_name": "MinorAxisLength"}}, {"numeric": {"column_name": "AspectRation"}}, {"numeric": {"column_name": "Eccentricity"}}, {"numeric": {"column_name": "ConvexArea"}}, {"numeric": {"column_name": "EquivDiameter"}}, {"numeric": {"column_name": "Extent"}}, {"numeric": {"column_name": "Solidity"}}, {"numeric": {"column_name": "roundness"}}, {"numeric": {"column_name": "Compactness"}}, {"numeric": {"column_name": "ShapeFactor1"}}, {"numeric": {"column_name": "ShapeFactor2"}}, {"numeric": {"column_name": "ShapeFactor3"}}, {"numeric": {"column_name": "ShapeFactor4"}}, {"categorical": {"column_name": "Class"}}, ], dataset=dataset_create_op.outputs["dataset"], target_column="Class", ) model_eval_task = classif_model_eval_metrics( project, gcp_region, api_endpoint, thresholds_dict_str, training_op.outputs["model"], ) with dsl.Condition( model_eval_task.outputs["dep_decision"] == "true", name="deploy_decision", ): deploy_op = gcc_aip.ModelDeployOp( # noqa: F841 model=training_op.outputs["model"], project=project, machine_type="e2-standard-4", )

Qué sucede con este código:

• Primero, así como en la canalización anterior, tú defines los parámetros de entrada que utiliza esta canalización. Debes establecerlos de forma manual, ya que no dependen del resultado de otros pasos.
• El resto de la canalización usa algunos componentes predefinidos para interactuar con los servicios de Vertex AI:
  • TabularDatasetCreateOp crea un conjunto de datos tabular en Vertex AI a partir de una fuente de conjunto de datos en Cloud Storage o BigQuery. En esta canalización, transfieres los datos mediante una URL de tabla de BigQuery.
  • AutoMLTabularTrainingJobRunOp inicia un trabajo de entrenamiento de AutoML para un conjunto de datos tabular. Tú transfieres algunos parámetros de configuración a este componente, incluidos el tipo de modelo (en este caso la clasificación), algunos datos en las columnas, cuánto tiempo te gustaría que se ejecute el entrenamiento y un puntero para el conjunto de datos. Ten en cuenta que, para transferir el conjunto de datos a este componente, debes proporcionar el resultado del componente anterior por medio de dataset_create_op.outputs["dataset"].
  • ModelDeployOp implementa un modelo proporcionado en un extremo de Vertex AI. Aunque existen opciones de configuración adicionales, aquí proporcionas el tipo de máquina, el proyecto y el modelo del extremo que quieres implementar. Para transferir el modelo, debes acceder a los resultados del paso de entrenamiento de tu canalización.
• Esta canalización también hace uso de una lógica condicional, una función de Vertex Pipelines que te permite definir una condición, junto con diferentes ramas basadas en el resultado de esa condición. Recuerda que cuando definiste la canalización, transferiste un parámetro thresholds_dict_str. Este es el umbral de precisión que utilizas para determinar si quieres implementar tu modelo en un extremo. Para implementarlo, utiliza la clase Condition del SDK de KFP. La condición que se transfiere es el resultado del componente de evaluación personalizado que definiste anteriormente en este lab. Si esta condición es verdadera, la canalización seguirá ejecutando el componente deploy_op. Si la precisión no cumple con el umbral predefinido, se detendrá la canalización y no se implementará el modelo.

Paso 3: Compila y ejecuta la canalización de AA de extremo a extremo

1. Luego de definir la canalización completa, es momento de compilarla:

compiler.Compiler().compile( pipeline_func=pipeline, package_path="tab_classif_pipeline.json" )

2. Luego, inicia una ejecución de canalización:

response = api_client.create_run_from_job_spec( "tab_classif_pipeline.json", pipeline_root=PIPELINE_ROOT, parameter_values={"project": PROJECT_ID,"display_name": DISPLAY_NAME} )

3. Haz clic en el vínculo que aparece luego de ejecutar la celda anterior para ver tu canalización en la consola. Esta canalización demorará aproximadamente una hora en ejecutarse. La mayor parte del tiempo se dedica a la etapa de entrenamiento de AutoML. La canalización completa se verá de forma similar a esta:

4. Si presionas el botón de activación “Expand artifacts” que aparece en la parte superior, podrás ver los detalles de los diferentes artefactos que creó tu canalización. Por ejemplo, si haces clic en el artefacto dataset verás los detalles del conjunto de datos de Vertex AI que se creó. Puedes hacer clic en este vínculo para ir a la página de ese conjunto de datos:

5. De forma similar, para conocer las visualizaciones de las métricas resultantes de tu componente de evaluación personalizado, haz clic en el artefacto llamado metricsc. En el lado derecho del panel, podrás ver la matriz de confusión de este modelo:

6. Para ver el modelo y el extremo creados a partir de la ejecución de esta canalización, dirígete a la sección de modelos y haz clic en el modelo llamado automl-beans. Ahí encontrarás este modelo implementado en un extremo:

7. También puedes acceder a esta página haciendo clic en el artefacto endpoint del gráfico de tu canalización.

8. Además de mirar el gráfico de la canalización en la consola, también puedes utilizar Vertex Pipelines para hacer un seguimiento del linaje.

9. Esto significa hacer un seguimiento de los artefactos que se crearon durante la canalización. De esta forma, podrás comprender dónde se crearon los artefactos y cómo se usan mediante un flujo de trabajo de AA. Por ejemplo, para ver el seguimiento del linaje del conjunto de datos que se creó en esta canalización, haz clic en el artefacto del conjunto de datos y, luego, en Ver linaje:

Aquí se muestran todos los lugares en los que se está utilizando este artefacto:

Nota: Espera hasta que el trabajo de entrenamiento de tu canalización haya comenzado y, luego, verifica su progreso a continuación. El trabajo de entrenamiento demorará más que el tiempo asignado para este lab, pero recibirás puntos por enviar el trabajo de entrenamiento correctamente. Verificar si se inició el trabajo de entrenamiento de la canalización de AA de extremo a extremo

Paso 4: Compara las métricas en las ejecuciones de las canalizaciones (opcional)

• Si ejecutas esta canalización varias veces, es probable que quieras comparar las métricas de las ejecuciones. Puedes utilizar el método aiplatform.get_pipeline_df() para acceder a los metadatos de la ejecución. En este paso, obtendrás los metadatos de todas las ejecuciones de esta canalización y los cargarás al DataFrame de Pandas:

pipeline_df = aiplatform.get_pipeline_df(pipeline="automl-tab-beans-training-v2") small_pipeline_df = pipeline_df.head(2) small_pipeline_df

Ya aprendiste a compilar, ejecutar y obtener metadatos para una canalización de AA de extremo a extremo en Vertex Pipelines.

¡Felicitaciones!

En este lab, creaste y ejecutaste una canalización de emoji. Además, aprendiste a compilar, ejecutar y obtener metadatos para una canalización de AA de extremo a extremo en Vertex Pipelines.

Próximos pasos/Más información

Intenta replicar la misma situación en tu propio proyecto de Google Cloud por medio del codelab de Relaciones con Desarrolladores.

• Introducción a Vertex Pipelines por Sara Robinson

Capacitación y certificación de Google Cloud

Recibe la formación que necesitas para aprovechar al máximo las tecnologías de Google Cloud. Nuestras clases incluyen habilidades técnicas y recomendaciones para ayudarte a avanzar rápidamente y a seguir aprendiendo. Para que puedas realizar nuestros cursos cuando más te convenga, ofrecemos distintos tipos de capacitación de nivel básico a avanzado: a pedido, presenciales y virtuales. Las certificaciones te ayudan a validar y demostrar tus habilidades y tu conocimiento técnico respecto a las tecnologías de Google Cloud.

Última actualización del manual: 28 de junio de 2024

Prueba más reciente del lab: 28 de junio de 2024

Copyright 2024 Google LLC. All rights reserved. Google y el logotipo de Google son marcas de Google LLC. Los demás nombres de productos y empresas pueden ser marcas de las respectivas empresas a las que estén asociados.