1. Descripción general
En este lab, analizarás un flujo de trabajo de AA completo en GCP. Desde un entorno de Cloud AI Platform Notebooks, transferirás datos de un conjunto de datos públicos de BigQuery, compilarás y entrenarás un modelo de XGBoost, y lo implementarás en AI Platform para la predicción.
Qué aprenderá
Aprenderás a hacer lo siguiente:
- Transfiere y analiza un conjunto de datos de BigQuery en AI Platform Notebooks
- Crea un modelo de XGBoost
- Implementa el modelo de 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. Configura 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 tipo de instancia de Python más reciente:
Usa las opciones predeterminadas y haz clic en Crear. Una vez que se crea la instancia, selecciona Abrir JupyterLab:
Paso 4: Instala XGBoost
Una vez que 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 este proceso, abre una instancia de notebook de Python 3 desde el selector. Ya puedes comenzar a usar tu notebook.
Paso 5: Importa paquetes de Python
En la primera celda del notebook, agrega las siguientes importaciones y ejecuta la celda. Para ejecutarlo, presiona el botón de flecha hacia la derecha en el menú superior o presiona Comando + 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 puso a disposición del público muchos conjuntos de datos para que los explores. En este lab, usaremos el conjunto de datos de natalidad. Contiene datos sobre casi todos los nacimientos en EE.UU. durante un período de 40 años, incluido el peso al nacer del niño y la información demográfica de los padres del bebé. Usaremos un subconjunto de las características para predecir el peso de un bebé al nacer.
Paso 1: Descarga los datos de BigQuery en nuestro notebook
Usaremos la biblioteca cliente de Python para BigQuery para descargar los datos en un DataFrame de Pandas. El conjunto de datos original tiene 21 GB y contiene 123 millones de filas. Para simplificar las cosas, solo usaremos 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 atrás, pero, para este modelo, solo usaremos datos posteriores al año 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 de nuestro conjunto de datos, ejecuta el siguiente comando:
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, obtengamos algunos datos sobre nuestra columna booleana que indica el sexo del bebé. Podemos hacerlo con el método value_counts de Pandas:
df['is_male'].value_counts()
Al parecer, el conjunto de datos está casi equilibrado en un 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, quita las filas con valores nulos del conjunto de datos y mezcla los datos:
df = df.dropna()
df = shuffle(df, random_state=2)
A continuación, 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 los cuatro atributos 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 cadenas de texto verdadero / falso. Para ello, simplemente 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 principio del notebook para dividir nuestros datos en conjuntos de entrenamiento y de prueba:
x,y = data,labels
x_train,x_test,y_train,y_test = train_test_split(x,y)
Ahora sí, ya podemos compilar y entrenar nuestro modelo.
5. Introducción rápida a XGBoost
XGBoost es un framework de aprendizaje automático que usa árboles de decisión y boosting de gradiente para compilar modelos predictivos. Funciona combinando varios árboles de decisión según la puntuación asociada a diferentes nodos hoja en un árbol.
El siguiente diagrama es una visualización simplificada de una red de árboles de conjunto para un modelo que evalúa si a alguien le gustará un juego de computadora específico (esto se extrajo de la documentación de XGBoost):
¿Por qué usamos XGBoost para este modelo? Si bien se demostró que las redes neuronales tradicionales funcionan mejor con datos no estructurados, como imágenes y texto, los árboles de decisión suelen tener un rendimiento excelente con datos estructurados, como el conjunto de datos de hipotecas que usaremos en este codelab.
6. Compila, entrena y evalúa un modelo de XGBoost
Paso 1: Define y entrena el modelo de XGBoost
Crear un modelo en XGBoost es simple. Usaremos la clase XGBRegressor para crear el modelo y solo necesitamos pasar el parámetro objective correcto para nuestra tarea específica. Aquí usamos un modelo de regresión, ya que predecimos un valor numérico (el peso del bebé). Si, en cambio, agrupáramos nuestros datos para determinar si un bebé pesó más o menos de 2.7 kg, usaríamos un modelo de clasificación.
En este caso, usaremos reg:squarederror como objetivo del modelo.
El siguiente código creará un modelo de XGBoost:
model = xgb.XGBRegressor(
objective='reg:linear'
)
Puedes entrenar el modelo con una sola línea de código, llamando al método fit() y pasándole los datos y las etiquetas de entrenamiento.
model.fit(x_train, y_train)
Paso 2: Evalúa tu modelo con datos de prueba
Ahora podemos usar nuestro modelo entrenado para generar predicciones sobre nuestros datos de prueba con la función predict():
y_pred = model.predict(x_test)
Veamos cómo se desempeñó el modelo con los primeros 20 valores de nuestro conjunto de prueba. A continuación, imprimiremos el peso predicho 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 para guardarlo en un archivo local:
model.save_model('model.bst')
7. Implementa el modelo en Cloud AI Platform
Ya tenemos nuestro modelo funcionando de forma local, pero sería bueno si pudiéramos hacer predicciones en é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 valores a continuación 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'
Ahora sí, podemos crear un bucket de almacenamiento para guardar nuestro archivo del modelo de XGBoost. Cuando implementemos el modelo, le indicaremos a AI Platform de Cloud que use este archivo.
Ejecuta este comando de gsutil desde tu notebook para crear un bucket:
!gsutil mb $MODEL_BUCKET
Paso 2: Copia el archivo del modelo en Cloud Storage
A continuación, copiaremos nuestro archivo del modelo guardado de XGBoost en Cloud Storage. Ejecuta el siguiente comando de gsutil:
!gsutil cp ./model.bst $MODEL_BUCKET
Dirígete al navegador de almacenamiento en tu consola de Cloud para confirmar que se copió el archivo:
Paso 3: Crea e implementa el modelo
El siguiente comando ai-platform de gcloud creará un modelo nuevo en tu proyecto. A esta la llamaremos xgb_mortgage:
!gcloud ai-platform models create $MODEL_NAME
Ahora es momento de implementar el modelo. Podemos hacerlo con este 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, consulta la sección de modelos de tu consola de AI Platform. Deberías ver que se implementa la nueva versión:
Cuando la implementación se complete correctamente, verás una marca de verificación verde donde se encontraba 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 tu modelo implementado funcione, pruébalo con gcloud para hacer una predicción. Primero, guarda un archivo JSON con dos ejemplos de nuestro conjunto de pruebas:
%%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 del modelo en el resultado. El peso real del bebé en estos dos ejemplos es de 0.86 y 3.67 kg, respectivamente.
8. Limpieza
Si quieres seguir usando este notebook, te recomendamos que lo desactives cuando no lo uses. 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, simplemente borra la instancia del notebook en lugar de detenerla.
En el menú de navegación de la consola de Cloud, navega a Almacenamiento y borra los dos buckets que creaste para almacenar los recursos del modelo.