1. Descripción general
En este lab, se explicará un flujo de trabajo completo de AA en GCP. Desde un entorno de Cloud AI Platform Notebooks, transferirás datos desde un conjunto de datos públicos de BigQuery, crearás y entrenarás un modelo XGBoost y, luego, implementarás el modelo en AI Platform para la predicción.
Qué aprenderá
Aprenderás a hacer lo siguiente:
- Transferir y analizar un conjunto de datos de BigQuery en AI Platform Notebooks
- Crea un modelo de XGBoost
- Implementa el modelo XGBoost en AI Platform y obtén predicciones
El costo total de la ejecución de este lab en Google Cloud es de aproximadamente $1.
2. 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 Cloud AI Platform Models
Navega a la sección Modelos de AI Platform de la consola de Cloud y haz clic en Habilitar si aún no está habilitada.
Paso 2: 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 3: Crea una instancia de AI Platform Notebooks
Navega a la sección AI Platform Notebooks de la consola de Cloud y haz clic en Instancia nueva. Luego, selecciona el último tipo de instancia de Python:
Usa las opciones predeterminadas y, luego, haz clic en Crear. Una vez que se crea la instancia, selecciona Abrir JupyterLab:
Paso 4: Instala XGBoost
Cuando se abra tu instancia de JupyterLab, deberás agregar el paquete XGBoost.
Para ello, selecciona Terminal en el selector:
Luego, ejecuta el siguiente comando para instalar la versión más reciente de XGBoost compatible con AI Platform:
pip3 install xgboost==0.82
Cuando se complete, abre una instancia de notebook de Python 3 desde el selector. Ya estás listo para comenzar con tu notebook.
Paso 5: Importa paquetes de Python
En la primera celda de tu notebook, agrega las siguientes importaciones y ejecuta la celda. Para ejecutarla, presiona el botón de la flecha hacia la derecha en el menú superior o presiona Command + Intro:
import pandas as pd
import xgboost as xgb
import numpy as np
from sklearn.model_selection import train_test_split
from sklearn.utils import shuffle
from google.cloud import bigquery
3. Explora el conjunto de datos de BigQuery
BigQuery permitió que muchos conjuntos de datos estén disponibles públicamente para que los explores. Para este lab, utilizaremos el conjunto de datos de natalidad. Esta información contiene datos sobre casi todos los nacimientos en los EE.UU. durante un período de 40 años, incluidos el peso del bebé al nacer y la información demográfica de sus padres. Usaremos un subconjunto de atributos para predecir el peso de un bebé al nacer.
Paso 1: Descarga los datos de BigQuery en nuestro notebook
Utilizaremos la biblioteca cliente de Python para BigQuery para descargar los datos en un DataFrame de Pandas. El conjunto de datos original es de 21 GB y contiene 123 millones de filas. Para mantener la simplicidad, solo utilizaremos 10,000 filas del conjunto de datos.
Construye la consulta y obtén una vista previa del DataFrame resultante con el siguiente código. Aquí, obtenemos 4 atributos del conjunto de datos original, junto con el peso del bebé (lo que predecirá nuestro modelo). El conjunto de datos se remonta a muchos años, pero para este modelo solo usaremos datos posteriores al 2000:
query="""
SELECT
weight_pounds,
is_male,
mother_age,
plurality,
gestation_weeks
FROM
publicdata.samples.natality
WHERE year > 2000
LIMIT 10000
"""
df = bigquery.Client().query(query).to_dataframe()
df.head()
Para obtener un resumen de los atributos numéricos en nuestro conjunto de datos, ejecuta lo siguiente:
df.describe()
Esto muestra la media, la desviación estándar, el mínimo y otras métricas para nuestras columnas numéricas. Por último, obtendremos algunos datos en nuestra columna booleana que indican el sexo del bebé. Podemos hacerlo con Pandas Método value_counts:
df['is_male'].value_counts()
Parece que el conjunto de datos está casi equilibrado en 50/50 por género.
4. Prepara los datos para el entrenamiento
En esta sección, dividiremos los datos en conjuntos de entrenamiento y prueba para prepararlos para entrenar nuestro modelo.
Paso 1: Extrae la columna de etiquetas
Primero, suelta las filas con valores nulos desde el conjunto de datos y redistribuye los datos:
df = df.dropna()
df = shuffle(df, random_state=2)
Luego, extrae la columna de etiquetas en una variable separada y crea un DataFrame solo con nuestros atributos:
labels = df['weight_pounds']
data = df.drop(columns=['weight_pounds'])
Ahora, si ejecutas data.head() para obtener una vista previa de nuestro conjunto de datos, deberías ver las cuatro funciones que usaremos para el entrenamiento.
Paso 2: Convierte los atributos categóricos en números enteros
Dado que XGBoost requiere que todos los datos sean numéricos, tendremos que cambiar la forma en que representamos los datos en la columna is_male, que actualmente son strings de verdadero / falso. Para hacerlo, solo cambia el tipo de esa columna:
data['is_male'] = data['is_male'].astype(int)
Paso 3: Divide los datos en conjuntos de entrenamiento y prueba
Usaremos la utilidad train_test_split de scikit-learn, que importamos al comienzo del notebook para dividir nuestros datos en conjuntos de entrenamiento y prueba:
x,y = data,labels
x_train,x_test,y_train,y_test = train_test_split(x,y)
Ya tenemos todo listo para crear y entrenar nuestro modelo.
5. Manual básico y rápido de XGBoost
XGBoost es un framework de aprendizaje automático que usa árboles de decisión y potenciación de gradientes para compilar modelos predictivos. Funciona en el ensamblaje de varios árboles de decisión en función de la puntuación asociada con diferentes nodos hoja en un árbol.
El siguiente diagrama es una visualización simplificada de una red de árbol de ensamble para un modelo que evalúa si a alguien le gustará o no un juego de computadora específico (esto es de los documentos de XGBoost):
¿Por qué usamos XGBoost para este modelo? Si bien se demostró que las redes neuronales tradicionales tienen un mejor rendimiento con datos no estructurados, como imágenes y texto, los árboles de decisión suelen tener un rendimiento excelente en datos estructurados, como el conjunto de datos hipotecarios que usaremos en este codelab.
6. Crea, entrena y evalúa un modelo XGBoost
Paso 1: Define y entrena el modelo de XGBoost
Crear un modelo en XGBoost es sencillo. Usaremos la clase XGBRegressor para crear el modelo y solo tendremos que pasar el parámetro objective correcto para nuestra tarea específica. Aquí usamos un modelo de regresión ya que estamos prediciendo un valor numérico (peso del bebé). Si estuviéramos agrupando nuestros datos para determinar si un bebé pesó más o menos de 6 libras, usaríamos un modelo de clasificación.
En este caso, usaremos reg:squarederror como el objetivo de nuestro modelo.
El siguiente código creará un modelo XGBoost:
model = xgb.XGBRegressor(
objective='reg:linear'
)
Puedes entrenar el modelo con una línea de código llamando al método fit() y pasándole los datos de entrenamiento y las etiquetas.
model.fit(x_train, y_train)
Paso 2: Evalúa tu modelo con los datos de prueba
Ahora podemos usar el modelo entrenado para generar predicciones sobre los datos de prueba con la función predict():
y_pred = model.predict(x_test)
Veamos el rendimiento del modelo en los primeros 20 valores del conjunto de prueba. A continuación, imprimiremos el peso previsto del bebé junto con el peso real del bebé para cada ejemplo de prueba:
for i in range(20):
print('Predicted weight: ', y_pred[i])
print('Actual weight: ', y_test.iloc[i])
print()
Paso 3: Guarda tu modelo
Para implementar el modelo, ejecuta el siguiente código y guárdalo en un archivo local:
model.save_model('model.bst')
7. Implementar el modelo en AI Platform de Cloud
Nuestro modelo está funcionando localmente, pero sería bueno poder hacer predicciones con él desde cualquier lugar (no solo desde este notebook). En este paso, lo implementaremos en la nube.
Paso 1: Crea un bucket de Cloud Storage para nuestro modelo
Primero, definamos algunas variables de entorno que usaremos durante el resto del codelab. Completa los siguientes valores con el nombre de tu proyecto de Google Cloud, el nombre del bucket de Cloud Storage que deseas crear (debe ser único a nivel global) y el nombre de la primera versión de tu modelo:
# Update these to your own GCP project, model, and version names
GCP_PROJECT = 'your-gcp-project'
MODEL_BUCKET = 'gs://storage_bucket_name'
VERSION_NAME = 'v1'
MODEL_NAME = 'baby_weight'
Ya tenemos todo listo para crear un bucket de almacenamiento y almacenar nuestro archivo del modelo XGBoost. Indicaremos Cloud AI Platform hacia este archivo cuando realicemos la implementación.
Ejecuta este comando gsutil desde tu notebook para crear un bucket:
!gsutil mb $MODEL_BUCKET
Paso 2: Copia el archivo de modelo en Cloud Storage
A continuación, copiaremos nuestro archivo del modelo guardado de XGBoost en Cloud Storage. Ejecuta el siguiente comando gsutil:
!gsutil cp ./model.bst $MODEL_BUCKET
Ve al navegador de almacenamiento en la consola de Cloud para confirmar que se copió el archivo:
Paso 3: Crea e implementa el modelo
El siguiente comando de gcloud ai-platform creará un modelo nuevo en tu proyecto. La llamaremos xgb_mortgage:
!gcloud ai-platform models create $MODEL_NAME
Ahora es el momento de implementar el modelo. Podemos hacerlo con el siguiente comando de gcloud:
!gcloud ai-platform versions create $VERSION_NAME \
--model=$MODEL_NAME \
--framework='XGBOOST' \
--runtime-version=1.15 \
--origin=$MODEL_BUCKET \
--python-version=3.7 \
--project=$GCP_PROJECT
Mientras se ejecuta, revisa la sección de modelos de la consola de AI Platform. Deberías ver tu nueva versión implementándose allí:
Cuando la implementación se complete correctamente, verás una marca de verificación verde donde se encuentra el ícono giratorio de carga. La implementación debería tardar entre 2 y 3 minutos.
Paso 4: Prueba el modelo implementado
Para asegurarte de que el modelo implementado funciona, pruébalo con gcloud para hacer una predicción. Primero, guarda un archivo JSON con dos ejemplos de nuestro conjunto de prueba:
%%writefile predictions.json
[0.0, 33.0, 1.0, 27.0]
[1.0, 26.0, 1.0, 40.0]
Para probar tu modelo, guarda el resultado del siguiente comando de gcloud en una variable y, luego, imprímelo:
prediction = !gcloud ai-platform predict --model=$MODEL_NAME --json-instances=predictions.json --version=$VERSION_NAME
print(prediction.s)
Deberías ver la predicción de tu modelo en el resultado. El peso real del bebé para estos dos ejemplos es de 1.9 y 8.1 libras, respectivamente.
8. Limpieza
Si quieres seguir utilizando este bloc de notas, 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 todos los recursos que creaste en este lab, solo borra la instancia de notebook en lugar de detenerla.
En el menú de navegación de la consola de Cloud, navega a Almacenamiento y borra los buckets que creaste para almacenar tus recursos del modelo.