1. Descripción general
En este lab, usarás Vertex AI para entrenar y entregar un modelo de TensorFlow con código alojado en un contenedor personalizado.
Si bien aquí usaremos TensorFlow para el código del modelo, puedes reemplazarlo fácilmente por otro framework.
Qué aprenderá
Aprenderás a hacer lo siguiente:
- Compila y aloja en contenedores el código de entrenamiento de modelos en Vertex Workbench
- Envía un trabajo de entrenamiento de modelo personalizado a Vertex AI
- Implementar el modelo entrenado en un extremo y usar ese extremo para obtener predicciones
El costo total de la ejecución de este lab en Google Cloud es de aproximadamente $1.
2. Introducción a Vertex AI
En este lab, se utiliza la oferta de productos de IA más reciente de Google Cloud. 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. La nueva oferta combina ambos en una sola API, junto con otros productos nuevos. También puedes migrar proyectos existentes a Vertex AI. Para enviarnos comentarios, visita la página de asistencia.
Vertex AI incluye muchos productos distintos para respaldar flujos de trabajo de AA de extremo a extremo. Este lab se enfocará en los productos que se destacan a continuación: Training, Prediction y Workbench.
3. Cómo configurar tu entorno
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: Habilita la API de Compute Engine
Ve a Compute Engine y selecciona Habilitar (si aún no está habilitada). La necesitarás para crear la instancia de notebook.
Paso 2: Habilita la API de Vertex AI
Navegue hasta la sección de Vertex AI en la consola de Cloud y haga clic en Habilitar API de Vertex AI.
Paso 3: Habilita la API de Container Registry
Navega a Container Registry y selecciona Habilitar si aún no lo has hecho. La usarás para crear un contenedor para tu trabajo de entrenamiento personalizado.
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 la versión más reciente del tipo de instancia TensorFlow Enterprise (con LTS) sin GPUs:
Usa las opciones predeterminadas y, luego, haz clic en Crear.
El modelo que entrenaremos y entregaremos en este lab se basa en este instructivo de la documentación de TensorFlow. En el instructivo, se usa el conjunto de datos Auto MPG de Kaggle para predecir la eficiencia del combustible de un vehículo.
4. Aloja el código de entrenamiento en contenedores
Para enviar este trabajo de entrenamiento a Vertex, colocaremos nuestro código de entrenamiento en un contenedor de Docker y lo enviaremos a Google Container Registry. Con este enfoque, podemos entrenar un modelo compilado con cualquier framework.
Para comenzar, en el menú Selector (Launcher), abre una ventana de terminal en tu instancia de notebook:
Crea un directorio nuevo llamado mpg y ábrelo con el comando cd:
mkdir mpg
cd mpg
Paso 1: Crea un Dockerfile
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 nuestra imagen. Se instalarán todas las bibliotecas que utilicemos y se configurará el punto de entrada para nuestro código de entrenamiento. En la terminal, crea un Dockerfile vacío:
touch Dockerfile
Abre el Dockerfile y copia lo siguiente:
FROM gcr.io/deeplearning-platform-release/tf2-cpu.2-6
WORKDIR /
# Copies the trainer code to the docker image.
COPY trainer /trainer
# Sets up the entry point to invoke the trainer.
ENTRYPOINT ["python", "-m", "trainer.train"]
Este Dockerfile usa la imagen de Docker con TensorFlow Enterprise 2.3 para contenedores de aprendizaje profundo. Los contenedores de aprendizaje profundo en Google Cloud tienen preinstalados muchos frameworks comunes de AA y ciencia de datos. El que estamos usando incluye TF Enterprise 2.3, Pandas, scikit-learn y más. Después de descargar esa imagen, este Dockerfile configura el punto de entrada para el código de entrenamiento. Aún no creamos estos archivos; en el siguiente paso, agregaremos el código para entrenar y exportar nuestro modelo.
Paso 2: Crea un bucket de Cloud Storage
En nuestro trabajo de entrenamiento, exportaremos el modelo entrenado de TensorFlow a un bucket de Cloud Storage. Vertex lo usará para leer los recursos exportados del modelo y, luego, implementarlo. Desde tu terminal, ejecuta lo siguiente para definir una variable de entorno para tu proyecto y asegúrate de reemplazar your-cloud-project con el ID de tu proyecto:
PROJECT_ID='your-cloud-project'
Luego, ejecuta el siguiente comando en tu terminal para crear un bucket nuevo en el proyecto. La marca -l (ubicación) es importante, ya que debe estar en la misma región en la que implementarás el extremo del modelo más adelante en el instructivo:
BUCKET_NAME="gs://${PROJECT_ID}-bucket"
gsutil mb -l us-central1 $BUCKET_NAME
Paso 3: Agrega el código de entrenamiento del modelo
En la terminal, ejecuta el siguiente comando para crear un directorio para nuestro código de entrenamiento y un archivo de Python en el que agregaremos el código:
mkdir trainer
touch trainer/train.py
Ahora, deberías tener lo siguiente en el directorio mpg/:
+ Dockerfile
+ trainer/
+ train.py
A continuación, abre el archivo train.py que acabas de crear y copia el código que aparece más abajo (se trata de una adaptación del instructivo que se proporciona en la documentación de TensorFlow).
Al comienzo del archivo, actualiza la variable BUCKET con el nombre del bucket de Storage que creaste en el paso anterior:
import numpy as np
import pandas as pd
import pathlib
import tensorflow as tf
from tensorflow import keras
from tensorflow.keras import layers
print(tf.__version__)
"""## The Auto MPG dataset
The dataset is available from the [UCI Machine Learning Repository](https://archive.ics.uci.edu/ml/).
### Get the data
First download the dataset.
"""
dataset_path = keras.utils.get_file("auto-mpg.data", "http://archive.ics.uci.edu/ml/machine-learning-databases/auto-mpg/auto-mpg.data")
dataset_path
"""Import it using pandas"""
column_names = ['MPG','Cylinders','Displacement','Horsepower','Weight',
'Acceleration', 'Model Year', 'Origin']
dataset = pd.read_csv(dataset_path, names=column_names,
na_values = "?", comment='\t',
sep=" ", skipinitialspace=True)
dataset.tail()
# TODO: replace `your-gcs-bucket` with the name of the Storage bucket you created earlier
BUCKET = 'gs://your-gcs-bucket'
"""### Clean the data
The dataset contains a few unknown values.
"""
dataset.isna().sum()
"""To keep this initial tutorial simple drop those rows."""
dataset = dataset.dropna()
"""The `"Origin"` column is really categorical, not numeric. So convert that to a one-hot:"""
dataset['Origin'] = dataset['Origin'].map({1: 'USA', 2: 'Europe', 3: 'Japan'})
dataset = pd.get_dummies(dataset, prefix='', prefix_sep='')
dataset.tail()
"""### Split the data into train and test
Now split the dataset into a training set and a test set.
We will use the test set in the final evaluation of our model.
"""
train_dataset = dataset.sample(frac=0.8,random_state=0)
test_dataset = dataset.drop(train_dataset.index)
"""### Inspect the data
Have a quick look at the joint distribution of a few pairs of columns from the training set.
Also look at the overall statistics:
"""
train_stats = train_dataset.describe()
train_stats.pop("MPG")
train_stats = train_stats.transpose()
train_stats
"""### Split features from labels
Separate the target value, or "label", from the features. This label is the value that you will train the model to predict.
"""
train_labels = train_dataset.pop('MPG')
test_labels = test_dataset.pop('MPG')
"""### Normalize the data
Look again at the `train_stats` block above and note how different the ranges of each feature are.
It is good practice to normalize features that use different scales and ranges. Although the model *might* converge without feature normalization, it makes training more difficult, and it makes the resulting model dependent on the choice of units used in the input.
Note: Although we intentionally generate these statistics from only the training dataset, these statistics will also be used to normalize the test dataset. We need to do that to project the test dataset into the same distribution that the model has been trained on.
"""
def norm(x):
return (x - train_stats['mean']) / train_stats['std']
normed_train_data = norm(train_dataset)
normed_test_data = norm(test_dataset)
"""This normalized data is what we will use to train the model.
Caution: The statistics used to normalize the inputs here (mean and standard deviation) need to be applied to any other data that is fed to the model, along with the one-hot encoding that we did earlier. That includes the test set as well as live data when the model is used in production.
## The model
### Build the model
Let's build our model. Here, we'll use a `Sequential` model with two densely connected hidden layers, and an output layer that returns a single, continuous value. The model building steps are wrapped in a function, `build_model`, since we'll create a second model, later on.
"""
def build_model():
model = keras.Sequential([
layers.Dense(64, activation='relu', input_shape=[len(train_dataset.keys())]),
layers.Dense(64, activation='relu'),
layers.Dense(1)
])
optimizer = tf.keras.optimizers.RMSprop(0.001)
model.compile(loss='mse',
optimizer=optimizer,
metrics=['mae', 'mse'])
return model
model = build_model()
"""### Inspect the model
Use the `.summary` method to print a simple description of the model
"""
model.summary()
"""Now try out the model. Take a batch of `10` examples from the training data and call `model.predict` on it.
It seems to be working, and it produces a result of the expected shape and type.
### Train the model
Train the model for 1000 epochs, and record the training and validation accuracy in the `history` object.
Visualize the model's training progress using the stats stored in the `history` object.
This graph shows little improvement, or even degradation in the validation error after about 100 epochs. Let's update the `model.fit` call to automatically stop training when the validation score doesn't improve. We'll use an *EarlyStopping callback* that tests a training condition for every epoch. If a set amount of epochs elapses without showing improvement, then automatically stop the training.
You can learn more about this callback [here](https://www.tensorflow.org/api_docs/python/tf/keras/callbacks/EarlyStopping).
"""
model = build_model()
EPOCHS = 1000
# The patience parameter is the amount of epochs to check for improvement
early_stop = keras.callbacks.EarlyStopping(monitor='val_loss', patience=10)
early_history = model.fit(normed_train_data, train_labels,
epochs=EPOCHS, validation_split = 0.2,
callbacks=[early_stop])
# Export model and save to GCS
model.save(BUCKET + '/mpg/model')
Paso 4: Compila y prueba el contenedor de manera local
En la terminal, define una variable con el URI de la imagen de contenedor en Google Container Registry:
IMAGE_URI="gcr.io/$PROJECT_ID/mpg:v1"
Luego, ejecuta el siguiente comando para compilar el contenedor desde la raíz de tu directorio mpg:
docker build ./ -t $IMAGE_URI
Ejecuta el contenedor en tu instancia de notebook para asegurarte de que esté funcionando correctamente:
docker run $IMAGE_URI
El modelo debería terminar el entrenamiento entre 1 y 2 minutos con una exactitud de la validación de alrededor del 72% (este valor puede variar). Cuando termines de ejecutar el contenedor de manera local, envíalo a Google Container Registry:
docker push $IMAGE_URI
Ahora que enviamos el contenedor a Container Registry, podemos iniciar un trabajo de entrenamiento de modelo personalizado.
5. Ejecuta un trabajo de entrenamiento en Vertex AI
Vertex AI proporciona las siguientes dos opciones para entrenar modelos:
- AutoML: Entrena modelos de alta calidad con poco esfuerzo y experiencia en AA.
- Entrenamiento personalizado: Ejecuta aplicaciones de entrenamiento personalizado en la nube con tu propio contenedor o uno de los creados previamente de Google Cloud.
En este lab, usaremos un entrenamiento personalizado a través de nuestro propio contenedor personalizado en Google Container Registry. Para comenzar, ve a Modelos en la sección Vertex de la consola de Cloud:
Paso 1: Inicia el trabajo de entrenamiento
Haz clic en Crear para ingresar los parámetros del trabajo de entrenamiento y el modelo implementado:
- En Conjunto de datos, selecciona No hay ningún conjunto de datos administrado.
- Selecciona Entrenamiento personalizado (avanzado) como método de entrenamiento y haz clic en Continuar.
- Haga clic en Continue.
En el siguiente paso, ingresa mpg (o el nombre que quieras asignarle a tu modelo) en Nombre del modelo. Luego, selecciona Contenedor personalizado:
En el cuadro de texto Imagen del contenedor, haz clic en Explorar y busca la imagen de Docker que acabas de subir a Container Registry. Deja el resto de los campos en blanco y haz clic en Continuar.
No usaremos el ajuste de hiperparámetros en este instructivo, así que deja desmarcada la casilla Enable hyperparameter tuning y haz clic en Continuar.
En Procesamiento y precios, no cambies la región seleccionada y elige n1-standard-4 como tu tipo de máquina:
Deja los campos del acelerador en blanco y selecciona Continuar. Debido a que el modelo que usamos en esta demostración se entrena rápidamente, emplearemos un tipo de máquina más pequeño.
En el paso Contenedor de predicción, selecciona Contenedor compilado previamente y, luego, TensorFlow 2.6.
Deja la configuración predeterminada para el contenedor previamente compilado sin modificar. En Directorio del modelo, ingresa el bucket de GCS con el subdirectorio mpg. Esta es la ruta de acceso en la secuencia de comandos de entrenamiento de modelos en la que exportas el modelo entrenado:
Vertex buscará en esta ubicación cuando implemente el modelo. Ahora puedes realizar el entrenamiento. Haz clic en Comenzar el entrenamiento para iniciar el trabajo de entrenamiento. En la sección Entrenamiento de la consola, verás algo como esto:
6. Implementa un extremo del modelo
Cuando configuramos nuestro trabajo de entrenamiento, especificamos el lugar en el que Vertex AI debería buscar los recursos exportados del modelo. Como parte de nuestra canalización de entrenamiento, Vertex creará un recurso del modelo según esta ruta del recurso. El recurso del modelo en sí no es un modelo implementado, pero una vez que tienes un modelo puedes implementarlo en un extremo. Para obtener más información sobre los modelos y los extremos en Vertex AI, consulta la documentación.
En este paso, crearemos un extremo para nuestro modelo entrenado. Podemos usar esta opción para obtener predicciones en nuestro modelo a través de la API de Vertex AI.
Paso 1: Implementa el extremo
Cuando se complete el trabajo de entrenamiento, deberías ver un modelo llamado mpg (o el nombre que le hayas asignado) en la sección Modelos de la consola:
Cuando se ejecutaba tu trabajo de entrenamiento, Vertex creó un recurso de modelo por ti. Para usar este modelo, debes implementar un extremo. Puedes tener muchos extremos por modelo. Haz clic en el modelo y, a continuación, en Implementar en el extremo.
Selecciona Crear extremo nuevo y asígnale un nombre, como v1. Deja seleccionada la opción Estándar para Acceso y, luego, haz clic en Continuar.
Deja la opción División del tráfico en 100 y, luego, ingresa 1 para Cantidad mínima de nodos de procesamiento. En Tipo de máquina, selecciona n1-standard-2 (o cualquier tipo de máquina que quieras). Deja el resto de los valores predeterminados seleccionados y haz clic en Continuar. No habilitaremos la supervisión para este modelo, así que haz clic en Implementar para iniciar la implementación del extremo.
La implementación del extremo tardará entre 10 y 15 minutos, y recibirás un correo electrónico cuando se complete. Cuando el extremo haya terminado de implementarse, verás lo siguiente, que muestra un extremo implementado en tu recurso del modelo:
Paso 2: Obtén predicciones en el modelo implementado
Obtendrás predicciones en nuestro modelo entrenado a partir de un notebook de Python con la API de Vertex Python. Regresa a la instancia de notebook y crea un notebook de Python 3 en el selector:
En el notebook, ejecute lo siguiente en una celda para instalar el SDK de Vertex AI:
!pip3 install google-cloud-aiplatform --upgrade --user
Luego, agrega una celda en el notebook para importar el SDK y crear una referencia al extremo que acabas de implementar:
from google.cloud import aiplatform
endpoint = aiplatform.Endpoint(
endpoint_name="projects/YOUR-PROJECT-NUMBER/locations/us-central1/endpoints/YOUR-ENDPOINT-ID"
)
Deberás reemplazar dos valores en la cadena endpoint_name anterior por el número y el extremo de tu proyecto. Para encontrar el número de tu proyecto, ve al panel del proyecto y obtén el valor del número de proyecto.
Puedes encontrar el ID de extremo en la sección Extremos de la consola aquí:
Por último, realiza una predicción en el extremo; para ello, copia y ejecuta el código que figura a continuación en una celda nueva:
test_mpg = [1.4838871833555929,
1.8659883497083019,
2.234620276849616,
1.0187816540094903,
-2.530890710602246,
-1.6046416850441676,
-0.4651483719733302,
-0.4952254087173721,
0.7746763768735953]
response = endpoint.predict([test_mpg])
print('API response: ', response)
print('Predicted MPG: ', response.predictions[0][0])
Este ejemplo ya tiene valores normalizados, que es el formato que espera nuestro modelo.
Ejecuta esta celda y deberías ver un resultado de predicción de alrededor de 16 millas por galón.
🎉 ¡Felicitaciones! 🎉
Aprendiste a usar Vertex AI para hacer lo siguiente:
- Entrenar un modelo suministrando el código de entrenamiento en un contenedor personalizado (en este ejemplo, usaste un modelo de TensorFlow, pero puedes entrenar un modelo creado con cualquier framework a través de contenedores personalizados)
- Implementar un modelo de TensorFlow con un contenedor previamente compilado como parte del mismo flujo de trabajo que usaste para el entrenamiento
- Crear un extremo del modelo y generar una predicción
Para obtener más información sobre las distintas partes de Vertex, consulte la documentación.
7. Limpieza
Si quieres continuar usando el notebook que creaste en este lab, te recomendamos que lo desactives cuando no lo utilices. En la IU de Workbench de la consola de Cloud, selecciona el notebook y, luego, haz clic en Detener.
Si quieres borrar el notebook por completo, haz clic en el botón Borrar (Delete) de la parte superior derecha.
Para borrar el extremo que implementaste, navega a la sección Extremos de la consola de Vertex AI, haz clic en el extremo que creaste y, luego, selecciona Anular la implementación del modelo en el extremo:
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):
