GSP273

Descripción general

En este lab, crearás una instancia de Vertex AI Workbench en la que desarrollarás un modelo de TensorFlow en un notebook de Jupyter. Luego, entrenarás el modelo, crearás una canalización de datos de entrada y la implementarás en un extremo, y obtendrás predicciones.

TensorFlow es una plataforma de código abierto de extremo a extremo para el aprendizaje automático. Cuenta con un ecosistema integral y flexible de herramientas, bibliotecas y recursos de la comunidad que permite que los investigadores innoven con el AA y los desarrolladores compilen e implementen aplicaciones con tecnología de AA fácilmente.

Vertex AI combina AutoML y AI Platform en una API unificada, una biblioteca cliente y una interfaz de usuario. Con Vertex AI, las opciones del entrenamiento de AutoML y el entrenamiento personalizado están disponibles.

Vertex AI Workbench ayuda a los usuarios a compilar con rapidez flujos de trabajo basados en notebooks de extremo a extremo a través de la integración profunda a servicios de datos (como Dataproc, Dataflow, BigQuery y Dataplex) y Vertex AI. Además, permite a los científicos de datos conectarse a los servicios de datos de Google Cloud, analizar conjuntos de datos, experimentar con diferentes técnicas de modelado, implementar los modelos entrenados en producción y administrar MLOps a lo largo del ciclo de vida del modelo.

Vertex AI Workbench es un único entorno de desarrollo para todo el flujo de trabajo de la ciencia de datos.

En este lab, se usan un conjunto de muestras de código y secuencias de comandos que se desarrollaron para la 2ª edición del libro Data Science on the Google Cloud Platform de O'Reilly Media, Inc.

Objetivos

• Implementar una instancia de Vertex AI Workbench
• Crear mínimos datos de validación y entrenamiento
• Crear la canalización de datos de entrada
• Crear un modelo de TensorFlow
• Implementar el modelo en Vertex AI
• Implementar el modelo de Explainable AI en Vertex AI
• Realizar predicciones desde el extremo del modelo

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: Implementa una instancia de Vertex AI Workbench

1. En el menú de navegación de la consola de Google Cloud, haz clic en Vertex AI > Workbench.

2. Haz clic en Crear nueva.

3. En el cuadro de diálogo Crear instancia, usa el nombre predeterminado o ingresa un nombre único para la instancia de Vertex AI Workbench. Define la región en y la zona en , y deja el resto de la configuración como predeterminada.

4. Haz clic en Crear.

5. Haz clic en Abrir JupyterLab.

Para usar un notebook, debes ingresar comandos en una celda. Asegúrate de ejecutar los comandos en la celda presionando Mayúsculas + Intro o haciendo clic en el triángulo que aparece en el menú superior del notebook para ejecutar las celdas seleccionadas y avanzar.

Implementar una instancia de Vertex AI Workbench

Tarea 2: Crea datos mínimos de validación y entrenamiento

1. En la sección del selector de Notebook, haz clic en Python 3 para abrir un notebook nuevo.

2. Importa bibliotecas Python y establece variables de entorno:

import os, json, math, shutil import numpy as np import tensorflow as tf !sudo apt install graphviz -y # environment variables used by bash cells PROJECT=!(gcloud config get-value project) PROJECT=PROJECT[0] REGION = '{{{project_0.default_region}}}' BUCKET='{}-dsongcp'.format(PROJECT) os.environ['ENDPOINT_NAME'] = 'flights' os.environ['BUCKET'] = BUCKET os.environ['REGION'] = REGION os.environ['TF_VERSION']='2-' + tf.__version__[2:4] Nota: Cuando pegues los comandos en la celda del notebook de Jupyter, recuerda ejecutar la celda para asegurarte de que el último comando de cualquier secuencia se ejecute antes de que continúes con el siguiente paso.

Puedes ignorar las advertencias de TensorRT Library Load o TensorFlow AVX2 FMA.

Exporta archivos que contengan los datos de entrenamiento y validación

Cuando se inicia el lab, se crean algunas tablas en el conjunto de datos de BigQuery. En esta sección, usarás BigQuery para crear tablas temporales en la plataforma que contengan los datos necesarios y, luego, exportarás las tablas a archivos CSV en Google Cloud Storage. Después, deberás borrar la tabla temporal. Más adelante, tendrás que leer y procesar esos archivos de datos CSV para crear los conjuntos de datos completo, de entrenamiento y de validación que necesitas para un modelo de TensorFlow personalizado.

1. Crea el conjunto de datos de entrenamiento flights_train_data para entrenar el modelo:

%%bigquery CREATE OR REPLACE TABLE dsongcp.flights_train_data AS SELECT IF(arr_delay < 15, 1.0, 0.0) AS ontime, dep_delay, taxi_out, distance, origin, dest, EXTRACT(hour FROM dep_time) AS dep_hour, IF (EXTRACT(dayofweek FROM dep_time) BETWEEN 2 AND 6, 1, 0) AS is_weekday, UNIQUE_CARRIER AS carrier, dep_airport_lat, dep_airport_lon, arr_airport_lat, arr_airport_lon FROM dsongcp.flights_tzcorr f JOIN dsongcp.trainday t ON f.FL_DATE = t.FL_DATE WHERE f.CANCELLED = False AND f.DIVERTED = False AND is_train_day = 'True'

2. Crea el conjunto de datos de evaluación flights_eval_data para evaluar el modelo:

%%bigquery CREATE OR REPLACE TABLE dsongcp.flights_eval_data AS SELECT IF(arr_delay < 15, 1.0, 0.0) AS ontime, dep_delay, taxi_out, distance, origin, dest, EXTRACT(hour FROM dep_time) AS dep_hour, IF (EXTRACT(dayofweek FROM dep_time) BETWEEN 2 AND 6, 1, 0) AS is_weekday, UNIQUE_CARRIER AS carrier, dep_airport_lat, dep_airport_lon, arr_airport_lat, arr_airport_lon FROM dsongcp.flights_tzcorr f JOIN dsongcp.trainday t ON f.FL_DATE = t.FL_DATE WHERE f.CANCELLED = False AND f.DIVERTED = False AND is_train_day = 'False'

3. Crea el conjunto de datos completo flights_all_data con el siguiente código:

%%bigquery CREATE OR REPLACE TABLE dsongcp.flights_all_data AS SELECT IF(arr_delay < 15, 1.0, 0.0) AS ontime, dep_delay, taxi_out, distance, origin, dest, EXTRACT(hour FROM dep_time) AS dep_hour, IF (EXTRACT(dayofweek FROM dep_time) BETWEEN 2 AND 6, 1, 0) AS is_weekday, UNIQUE_CARRIER AS carrier, dep_airport_lat, dep_airport_lon, arr_airport_lat, arr_airport_lon, IF (is_train_day = 'True', IF(ABS(MOD(FARM_FINGERPRINT(CAST(f.FL_DATE AS STRING)), 100)) < 60, 'TRAIN', 'VALIDATE'), 'TEST') AS data_split FROM dsongcp.flights_tzcorr f JOIN dsongcp.trainday t ON f.FL_DATE = t.FL_DATE WHERE f.CANCELLED = False AND f.DIVERTED = False

4. Exporta los conjuntos de datos completo, de entrenamiento y de validación en formato de archivo CSV al bucket de Google Cloud Storage:

Este proceso tardará unos 2 minutos en completarse.

5. Espera hasta que recibas el resultado de la ejecución de la siguiente secuencia de comandos de Bash en la celda del notebook:

%%bash PROJECT=$(gcloud config get-value project) for dataset in "train" "eval" "all"; do TABLE=dsongcp.flights_${dataset}_data CSV=gs://${BUCKET}/ch9/data/${dataset}.csv echo "Exporting ${TABLE} to ${CSV} and deleting table" bq --project_id=${PROJECT} extract --destination_format=CSV $TABLE $CSV bq --project_id=${PROJECT} rm -f $TABLE done

6. Genera una lista de los objetos exportados en el bucket de Google Cloud Storage con el siguiente código:

!gsutil ls -lh gs://{BUCKET}/ch9/data Crear el conjunto de datos de entrenamiento y validación

Tarea 3: Crea los datos de entrada

Configuración en el notebook

1. Con fines de desarrollo, entrena el modelo por algunos ciclos de entrenamiento. Por eso los NUM_EXAMPLES son tan bajos.

DEVELOP_MODE = True NUM_EXAMPLES = 5000*1000

2. Asigna el URI de tus datos de entrenamiento y validación a training_data_uri y validation_data_uri, respectivamente:

training_data_uri = 'gs://{}/ch9/data/train*'.format(BUCKET) validation_data_uri = 'gs://{}/ch9/data/eval*'.format(BUCKET)

3. Configura los parámetros del modelo con el siguiente bloque de código:

NBUCKETS = 5 NEMBEDS = 3 TRAIN_BATCH_SIZE = 64 DNN_HIDDEN_UNITS = '64,32'

Lee datos en TensorFlow

1. Para leer los archivos CSV desde Google Cloud Storage en TensorFlow, usa un método desde el paquete tf.data:

if DEVELOP_MODE: train_df = tf.data.experimental.make_csv_dataset(training_data_uri, batch_size=5) for n, data in enumerate(train_df): numpy_data = {k: v.numpy() for k, v in data.items()} print(n, numpy_data) if n==1: break

Escribe funciones features_and_labels() y read_dataset(). La función read_dataset() lee los datos de entrenamiento, genera ejemplos de batch_size cada vez que lo hace y te permite detener las iteraciones cuando se haya leído una cantidad determinada de ejemplos.

El conjunto de datos contiene todas las columnas del archivo CSV, denominadas según la línea de encabezado. Estos datos están conformados por atributos y la etiqueta. Es mejor separarlos escribiendo la función features_and_labels() para que el código posterior sea más fácil de leer. Por lo tanto, aplicaremos una función pop() al diccionario y devolveremos una tupla de funciones y etiquetas.

2. Ingresa y ejecuta el siguiente código:

def features_and_labels(features): label = features.pop('ontime') return features, label def read_dataset(pattern, batch_size, mode=tf.estimator.ModeKeys.TRAIN, truncate=None): dataset = tf.data.experimental.make_csv_dataset(pattern, batch_size, num_epochs=1) dataset = dataset.map(features_and_labels) if mode == tf.estimator.ModeKeys.TRAIN: dataset = dataset.shuffle(batch_size*10) dataset = dataset.repeat() dataset = dataset.prefetch(1) if truncate is not None: dataset = dataset.take(truncate) return dataset if DEVELOP_MODE: print("Checking input pipeline") one_item = read_dataset(training_data_uri, batch_size=2, truncate=1) print(list(one_item)) # should print one batch of 2 items

Tarea 4. Crea, entrena y evalúa el modelo de TensorFlow

Por lo general, debes crear un atributo para cada columna de los datos tabulares. Keras es compatible con las columnas de atributos, lo que permite representar datos estructurados con técnicas de ingeniería de atributos estándar, como la incorporación, el agrupamiento en buckets y las combinaciones de atributos. Ya que los datos numéricos pueden pasarse directamente al modelo de AA, debes mantener las columnas con valores reales separadas de las columnas dispersas (o de cadena).

1. Ingresa y ejecuta el siguiente código:

import tensorflow as tf real = { colname : tf.feature_column.numeric_column(colname) for colname in ( 'dep_delay,taxi_out,distance,dep_hour,is_weekday,' + 'dep_airport_lat,dep_airport_lon,' + 'arr_airport_lat,arr_airport_lon' ).split(',') } sparse = { 'carrier': tf.feature_column.categorical_column_with_vocabulary_list('carrier', vocabulary_list='AS,VX,F9,UA,US,WN,HA,EV,MQ,DL,OO,B6,NK,AA'.split(',')), 'origin' : tf.feature_column.categorical_column_with_hash_bucket('origin', hash_bucket_size=1000), 'dest' : tf.feature_column.categorical_column_with_hash_bucket('dest', hash_bucket_size=1000), }

Todos estos atributos provienen directamente del archivo de entrada (y los proporciona cualquier cliente que quiera una predicción para un vuelo). Las capas de entrada tienen correspondencia 1:1 con los atributos de entrada y sus tipos, así que en lugar de repetir los nombres de las columnas, debes crear una capa de entrada para cada una de estas columnas y especificar el tipo de datos correcto (un número de punto flotante o una cadena).

2. Ingresa y ejecuta el siguiente código:

inputs = { colname : tf.keras.layers.Input(name=colname, shape=(), dtype='float32') for colname in real.keys() } inputs.update({ colname : tf.keras.layers.Input(name=colname, shape=(), dtype='string') for colname in sparse.keys() })

Agrupamiento

Las columnas con valores reales cuya precisión es excesiva (por lo tanto, es probable que cause sobreajuste) pueden discretizarse y convertirse en columnas categóricas. Por ejemplo, si tienes una columna para la antigüedad del avión, puedes discretizarla en simplemente tres grupos: menos de 5 años de antigüedad, entre 5 y 20 años de antigüedad y más de 20 años de antigüedad. Puedes usar el atajo de discretización para discretizar las latitudes y longitudes, y combinar los buckets. Esto genera el desglose del país en cuadrículas, y se obtiene el punto de cuadrícula en que se ubican una latitud y longitud específicas.

• Ingresa y ejecuta el siguiente código:

latbuckets = np.linspace(20.0, 50.0, NBUCKETS).tolist() # USA lonbuckets = np.linspace(-120.0, -70.0, NBUCKETS).tolist() # USA disc = {} disc.update({ 'd_{}'.format(key) : tf.feature_column.bucketized_column(real[key], latbuckets) for key in ['dep_airport_lat', 'arr_airport_lat'] }) disc.update({ 'd_{}'.format(key) : tf.feature_column.bucketized_column(real[key], lonbuckets) for key in ['dep_airport_lon', 'arr_airport_lon'] }) # cross columns that make sense in combination sparse['dep_loc'] = tf.feature_column.crossed_column( [disc['d_dep_airport_lat'], disc['d_dep_airport_lon']], NBUCKETS*NBUCKETS) sparse['arr_loc'] = tf.feature_column.crossed_column( [disc['d_arr_airport_lat'], disc['d_arr_airport_lon']], NBUCKETS*NBUCKETS) sparse['dep_arr'] = tf.feature_column.crossed_column([sparse['dep_loc'], sparse['arr_loc']], NBUCKETS ** 4) # embed all the sparse columns embed = { 'embed_{}'.format(colname) : tf.feature_column.embedding_column(col, NEMBEDS) for colname, col in sparse.items() } real.update(embed) # one-hot encode the sparse columns sparse = { colname : tf.feature_column.indicator_column(col) for colname, col in sparse.items() } if DEVELOP_MODE: print(sparse.keys()) print(real.keys())

Entrena y evalúa el modelo

1. Guarda el punto de control:

output_dir='gs://{}/ch9/trained_model'.format(BUCKET) os.environ['OUTDIR'] = output_dir # needed for deployment print('Writing trained model to {}'.format(output_dir))

2. Borra los puntos de control del modelo que ya se encuentran en el bucket de almacenamiento con el siguiente código:

!gsutil -m rm -rf $OUTDIR

Este comando devolverá un error que indica CommandException: 1 files/objects could not be removed porque aún no se ha guardado el modelo. El error indica que no hay archivos en la ubicación de destino. Debes asegurarte de que la ubicación esté vacía antes de intentar guardar el modelo; esto es lo que nos garantiza este comando.

3. Ahora que las columnas de atributos reales y dispersas se mejoraron más allá de las entradas sin procesar, puedes crear un wide_and_deep_classifier pasando las columnas de atributos profundas y lineales de manera separada:

# Build a wide-and-deep model. def wide_and_deep_classifier(inputs, linear_feature_columns, dnn_feature_columns, dnn_hidden_units): deep = tf.keras.layers.DenseFeatures(dnn_feature_columns, name='deep_inputs')(inputs) layers = [int(x) for x in dnn_hidden_units.split(',')] for layerno, numnodes in enumerate(layers): deep = tf.keras.layers.Dense(numnodes, activation='relu', name='dnn_{}'.format(layerno+1))(deep) wide = tf.keras.layers.DenseFeatures(linear_feature_columns, name='wide_inputs')(inputs) both = tf.keras.layers.concatenate([deep, wide], name='both') output = tf.keras.layers.Dense(1, activation='sigmoid', name='pred')(both) model = tf.keras.Model(inputs, output) model.compile(optimizer='adam', loss='binary_crossentropy', metrics=['accuracy']) return model model = wide_and_deep_classifier( inputs, linear_feature_columns = sparse.values(), dnn_feature_columns = real.values(), dnn_hidden_units = DNN_HIDDEN_UNITS) tf.keras.utils.plot_model(model, 'flights_model.png', show_shapes=False, rankdir='LR')

Usa train_dataset para el entrenamiento del modelo, y eval_dataset para su evaluación.

4. Crea el modelo con los siguientes bloques de código:

# training and evaluation dataset train_batch_size = TRAIN_BATCH_SIZE if DEVELOP_MODE: eval_batch_size = 100 steps_per_epoch = 3 epochs = 2 num_eval_examples = eval_batch_size*10 else: eval_batch_size = 100 steps_per_epoch = NUM_EXAMPLES // train_batch_size epochs = 10 num_eval_examples = eval_batch_size * 100 train_dataset = read_dataset(training_data_uri, train_batch_size) eval_dataset = read_dataset(validation_data_uri, eval_batch_size, tf.estimator.ModeKeys.EVAL, num_eval_examples) checkpoint_path = '{}/checkpoints/flights.cpt'.format(output_dir) shutil.rmtree(checkpoint_path, ignore_errors=True) cp_callback = tf.keras.callbacks.ModelCheckpoint(checkpoint_path, save_weights_only=True, verbose=1) history = model.fit(train_dataset, validation_data=eval_dataset, epochs=epochs, steps_per_epoch=steps_per_epoch, callbacks=[cp_callback])

5. Visualiza la pérdida y la exactitud del modelo con matplotlib.pyplot:

import matplotlib.pyplot as plt nrows = 1 ncols = 2 fig = plt.figure(figsize=(10, 5)) for idx, key in enumerate(['loss', 'accuracy']): ax = fig.add_subplot(nrows, ncols, idx+1) plt.plot(history.history[key]) plt.plot(history.history['val_{}'.format(key)]) plt.title('model {}'.format(key)) plt.ylabel(key) plt.xlabel('epoch') plt.legend(['train', 'validation'], loc='upper left');

El resultado es similar al siguiente:

Nota: Es posible que la pérdida del entrenamiento y el gráfico de exactitud del modelo no coincidan, ya que realizas el entrenamiento en una muestra aleatoria demasiado pequeña.

Exporta el modelo entrenado

• Guarda los artefactos del modelo en el bucket de Google Cloud Storage:

import time export_dir = '{}/export/flights_{}'.format(output_dir, time.strftime("%Y%m%d-%H%M%S")) print('Exporting to {}'.format(export_dir)) tf.saved_model.save(model, export_dir) Crear el modelo de TensorFlow

Tarea 5: Implementa el modelo de vuelos en Vertex AI

Vertex AI proporciona un entorno completamente administrado, con ajuste de escala automático y sin servidores para los modelos de aprendizaje automático. Obtienes los beneficios de pagar por cualquier recurso de procesamiento (como las CPUs o GPU) solo cuando lo usas. Debido a que los modelos se alojan en contenedores, no tienes que preocuparte por la administración de dependencias. Los extremos se encargan de las divisiones del tráfico, lo que te permite realizar pruebas A/B de forma conveniente.

Los beneficios no se limitan solo a no tener que administrar la infraestructura. Después de que implementes el modelo en Vertex AI, obtendrás muchas funciones interesantes sin código adicional, como la explicabilidad, la detección de desvíos, la supervisión y mucho más.

1. Crea el extremo de modelo flights con la siguiente celda de código y borra los modelos existentes que tienen el mismo nombre:

%%bash # note TF_VERSION and ENDPOINT_NAME set in 1st cell # TF_VERSION=2-6 # ENDPOINT_NAME=flights TIMESTAMP=$(date +%Y%m%d-%H%M%S) MODEL_NAME=${ENDPOINT_NAME}-${TIMESTAMP} EXPORT_PATH=$(gsutil ls ${OUTDIR}/export | tail -1) echo $EXPORT_PATH # create the model endpoint for deploying the model if [[ $(gcloud beta ai endpoints list --region=$REGION \ --format='value(DISPLAY_NAME)' --filter=display_name=${ENDPOINT_NAME}) ]]; then echo "Endpoint for $MODEL_NAME already exists" else echo "Creating Endpoint for $MODEL_NAME" gcloud beta ai endpoints create --region=${REGION} --display-name=${ENDPOINT_NAME} fi ENDPOINT_ID=$(gcloud beta ai endpoints list --region=$REGION \ --format='value(ENDPOINT_ID)' --filter=display_name=${ENDPOINT_NAME}) echo "ENDPOINT_ID=$ENDPOINT_ID" # delete any existing models with this name for MODEL_ID in $(gcloud beta ai models list --region=$REGION --format='value(MODEL_ID)' --filter=display_name=${MODEL_NAME}); do echo "Deleting existing $MODEL_NAME ... $MODEL_ID " gcloud ai models delete --region=$REGION $MODEL_ID done # create the model using the parameters docker conatiner image and artifact uri gcloud beta ai models upload --region=$REGION --display-name=$MODEL_NAME \ --container-image-uri=us-docker.pkg.dev/vertex-ai/prediction/tf2-cpu.${TF_VERSION}:latest \ --artifact-uri=$EXPORT_PATH MODEL_ID=$(gcloud beta ai models list --region=$REGION --format='value(MODEL_ID)' --filter=display_name=${MODEL_NAME}) echo "MODEL_ID=$MODEL_ID" # deploy the model to the endpoint gcloud beta ai endpoints deploy-model $ENDPOINT_ID \ --region=$REGION \ --model=$MODEL_ID \ --display-name=$MODEL_NAME \ --machine-type=e2-standard-2 \ --min-replica-count=1 \ --max-replica-count=1 \ --traffic-split=0=100 Nota: En ocasiones, puede producirse un error aproximadamente 5 minutos después de que se inicie este proceso. Si encuentras un error de compilación del modelo, por ejemplo, que la cuenta de servicio no tiene los permisos suficientes para escribir objetos en el bucket de Google Cloud Storage, vuelve a ejecutar la celda de código. Además, debes habilitar la API de Vertex AI si no está habilitada. Nota: El proceso de creación del modelo y del extremo del modelo, y de implementación del modelo en el extremo tardará entre 15 y 20 minutos. Si no puedes acceder al vínculo del extremo que se generó, ignóralo. Para ver el progreso en la consola de Cloud, haz clic en el menú de navegación > Vertex AI > Predicción en línea > Extremos. Implementar el modelo de vuelos en Vertex AI

2. Crea un archivo de entrada de prueba example_input.json con el siguiente código:

%%writefile example_input.json {"instances": [ {"dep_hour": 2, "is_weekday": 1, "dep_delay": 40, "taxi_out": 17, "distance": 41, "carrier": "AS", "dep_airport_lat": 58.42527778, "dep_airport_lon": -135.7075, "arr_airport_lat": 58.35472222, "arr_airport_lon": -134.57472222, "origin": "GST", "dest": "JNU"}, {"dep_hour": 22, "is_weekday": 0, "dep_delay": -7, "taxi_out": 7, "distance": 201, "carrier": "HA", "dep_airport_lat": 21.97611111, "dep_airport_lon": -159.33888889, "arr_airport_lat": 20.89861111, "arr_airport_lon": -156.43055556, "origin": "LIH", "dest": "OGG"} ]}

3. Realiza una predicción desde el extremo del modelo. Aquí tienes los datos de entrada en un archivo JSON llamado example_input.json:

%%bash ENDPOINT_ID=$(gcloud beta ai endpoints list --region=$REGION \ --format='value(ENDPOINT_ID)' --filter=display_name=${ENDPOINT_NAME}) echo $ENDPOINT_ID gcloud beta ai endpoints predict $ENDPOINT_ID --region=$REGION --json-request=example_input.json

Esta es la forma en que los programas cliente pueden invocar el modelo que implementaste.

Da por sentado que tienen los datos de entrada en un archivo JSON llamado example_input.json.

4. Ahora, envía una solicitud POST de HTTP y obtendrás el resultado en formato JSON:

%%bash PROJECT=$(gcloud config get-value project) ENDPOINT_ID=$(gcloud beta ai endpoints list --region=$REGION \ --format='value(ENDPOINT_ID)' --filter=display_name=${ENDPOINT_NAME}) curl -X POST \ -H "Authorization: Bearer "$(gcloud auth application-default print-access-token) \ -H "Content-Type: application/json; charset=utf-8" \ -d @example_input.json \ "https://${REGION}-aiplatform.googleapis.com/v1/projects/${PROJECT}/locations/${REGION}/endpoints/${ENDPOINT_ID}:predict"

Tarea 6: Explicabilidad del modelo

La explicabilidad del modelo es uno de los problemas más importantes en el aprendizaje automático. Es un concepto amplio relacionado con el análisis y la comprensión de los resultados que proporcionan los modelos de aprendizaje automático. La explicabilidad en el aprendizaje automático significa que puedes explicar lo que sucede en tu modelo desde la entrada hasta el resultado. Hace que el modelo sea transparente y resuelve el problema de la caja negra. Explainable AI (XAI) es la manera más formal de describir este concepto.

1. Ejecuta el siguiente código:

%%bash model_dir=$(gsutil ls ${OUTDIR}/export | tail -1) echo $model_dir saved_model_cli show --tag_set serve --signature_def serving_default --dir $model_dir

2. Crea un archivo JSON explanation-metadata.json que contenga los metadatos que describen la entrada y el resultado del modelo para explicarlos. Aquí, usarás el método sampled-shapley que se utiliza para la explicación:

cols = ('dep_delay,taxi_out,distance,dep_hour,is_weekday,' + 'dep_airport_lat,dep_airport_lon,' + 'arr_airport_lat,arr_airport_lon,' + 'carrier,origin,dest') inputs = {x: {"inputTensorName": "{}".format(x)} for x in cols.split(',')} expl = { "inputs": inputs, "outputs": { "pred": { "outputTensorName": "pred" } } } print(expl) with open('explanation-metadata.json', 'w') as ofp: json.dump(expl, ofp, indent=2)

3. Visualiza el archivo explanation-metadata.json con el comando cat:

!cat explanation-metadata.json

Crea otro modelo flights_xai y, luego, impleméntalo en Vertex AI

• Crea el extremo de modelo flights_xai, sube el modelo y, luego, impleméntalo en el extremo con el siguiente código:

%%bash # note ENDPOINT_NAME is being changed ENDPOINT_NAME=flights_xai TIMESTAMP=$(date +%Y%m%d-%H%M%S) MODEL_NAME=${ENDPOINT_NAME}-${TIMESTAMP} EXPORT_PATH=$(gsutil ls ${OUTDIR}/export | tail -1) echo $EXPORT_PATH # create the model endpoint for deploying the model if [[ $(gcloud beta ai endpoints list --region=$REGION \ --format='value(DISPLAY_NAME)' --filter=display_name=${ENDPOINT_NAME}) ]]; then echo "Endpoint for $MODEL_NAME already exists" else # create model endpoint echo "Creating Endpoint for $MODEL_NAME" gcloud beta ai endpoints create --region=${REGION} --display-name=${ENDPOINT_NAME} fi ENDPOINT_ID=$(gcloud beta ai endpoints list --region=$REGION \ --format='value(ENDPOINT_ID)' --filter=display_name=${ENDPOINT_NAME}) echo "ENDPOINT_ID=$ENDPOINT_ID" # delete any existing models with this name for MODEL_ID in $(gcloud beta ai models list --region=$REGION --format='value(MODEL_ID)' --filter=display_name=${MODEL_NAME}); do echo "Deleting existing $MODEL_NAME ... $MODEL_ID " gcloud ai models delete --region=$REGION $MODEL_ID done # upload the model using the parameters docker conatiner image, artifact URI, explanation method, # explanation path count and explanation metadata JSON file `explanation-metadata.json`. # Here, you keep number of feature permutations to `10` when approximating the Shapley values for explanation. gcloud beta ai models upload --region=$REGION --display-name=$MODEL_NAME \ --container-image-uri=us-docker.pkg.dev/vertex-ai/prediction/tf2-cpu.${TF_VERSION}:latest \ --artifact-uri=$EXPORT_PATH \ --explanation-method=sampled-shapley --explanation-path-count=10 --explanation-metadata-file=explanation-metadata.json MODEL_ID=$(gcloud beta ai models list --region=$REGION --format='value(MODEL_ID)' --filter=display_name=${MODEL_NAME}) echo "MODEL_ID=$MODEL_ID" # deploy the model to the endpoint gcloud beta ai endpoints deploy-model $ENDPOINT_ID \ --region=$REGION \ --model=$MODEL_ID \ --display-name=$MODEL_NAME \ --machine-type=e2-standard-2 \ --min-replica-count=1 \ --max-replica-count=1 \ --traffic-split=0=100 Nota: El proceso de creación del modelo y del extremo del modelo, y de implementación del modelo en el extremo tardará entre 15 y 20 minutos. Si no puedes acceder al vínculo del extremo que se generó, ignóralo. Para ver el progreso en la consola de Cloud, haz clic en el menú de navegación > Vertex AI > Predicción en línea > Extremos. Implementar el modelo flights_xai en Vertex AI

Tarea 7: Invoca el modelo implementado

Esta es la forma en que los programas cliente pueden invocar el modelo que implementaste. Da por sentado que tienen los datos de entrada en un archivo JSON llamado example_input.json. Ahora, envía una solicitud POST de HTTP y obtendrás el resultado en formato JSON.

• Ejecuta el siguiente código:

%%bash PROJECT=$(gcloud config get-value project) ENDPOINT_NAME=flights_xai ENDPOINT_ID=$(gcloud beta ai endpoints list --region=$REGION \ --format='value(ENDPOINT_ID)' --filter=display_name=${ENDPOINT_NAME}) curl -X POST \ -H "Authorization: Bearer "$(gcloud auth application-default print-access-token) \ -H "Content-Type: application/json; charset=utf-8" \ -d @example_input.json \ "https://${REGION}-aiplatform.googleapis.com/v1/projects/${PROJECT}/locations/${REGION}/endpoints/${ENDPOINT_ID}:explain"

¡Felicitaciones!

¡Felicitaciones! En este lab, aprendiste a crear un modelo con Vertex AI y a implementarlo en extremos de Vertex AI. También aprendiste a usar la función Explainable AI (XAI) de Vertex AI para explicar las predicciones del modelo. Luego, entrenaste un modelo de regresión logística con todos los valores de entrada y descubriste que el modelo era incapaz de utilizar eficazmente los atributos nuevos, como las ubicaciones de aeropuertos.

Próximos pasos y más información

• Data Science on the Google Cloud Platform, 2nd Edition: O'Reilly Media, Inc.

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: 30 de octubre de 2023

Prueba más reciente del lab: 31 de octubre de 2023

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.