1. Descripción general
En este lab, se explican varias herramientas de AI Platform Notebooks para explorar tus datos y el prototipado de modelos de AA.
Qué aprenderá
Aprenderás a hacer lo siguiente:
- Crea y personaliza una instancia de AI Platform Notebooks
- Realiza un seguimiento del código de tus notebooks con Git, integrado directamente en AI Platform Notebooks
- Usa la Herramienta What-If en tu notebook
El costo total de la ejecución de este lab en Google Cloud es de aproximadamente $1. Puedes encontrar todos los detalles sobre los precios de AI Platform Notebooks aquí.
2. Crea una instancia de AI Platform Notebooks
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 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 notebook
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 TensorFlow 2 Enterprise más reciente sin GPU:
Asigna un nombre a la instancia o usa el predeterminado. Luego, exploraremos las opciones de personalización. Haz clic en el botón Customize:
AI Platform Notebooks tiene muchas opciones de personalización diferentes, incluidas la región en la que se implementa la instancia, el tipo de imagen, el tamaño de la máquina, la cantidad de GPU y mucho más. Usaremos los valores predeterminados para la región y el entorno. Para la configuración de la máquina, usaremos una máquina n1-standard-8:
No agregaremos ninguna GPU y usaremos los valores predeterminados para el disco de arranque, las redes y los permisos. Selecciona Crear para crear tu instancia. Este proceso tardará unos minutos en completarse.
Una vez que se haya creado la instancia, verás una marca de verificación verde junto a ella en la IU de Notebooks. Selecciona Open JupyterLab para abrir tu instancia y comenzar el prototipado:
Cuando abras la instancia, crea un nuevo directorio llamado codelab. Este es el directorio desde el que trabajaremos durante el lab:
Para acceder al directorio del codelab que acabas de crear, haz doble clic en él y, luego, selecciona el notebook de Python 3 en el selector:
Cambia el nombre del notebook a demo.ipynb o el nombre que quieras asignarle.
Paso 4: Importa paquetes de Python
Crea una nueva celda en el notebook y, luego, importa las bibliotecas que usaremos en este codelab:
import pandas as pd
import tensorflow as tf
from tensorflow.keras import Sequential
from tensorflow.keras.layers import Dense
import numpy as np
import json
from sklearn.model_selection import train_test_split
from sklearn.utils import shuffle
from google.cloud import bigquery
from witwidget.notebook.visualization import WitWidget, WitConfigBuilder
3. Conecta los datos de BigQuery a tu notebook
BigQuery, el almacén de macrodatos de Google Cloud, ha puesto muchos conjuntos de datos a disposición del público para que los explores. AI Platform Notebooks admite la integración directa con BigQuery sin necesidad de autenticación.
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 el método value_counts de Pandas:
df['is_male'].value_counts()
Parece que el conjunto de datos está casi equilibrado en 50/50 por género.
Paso 2: Prepara el conjunto de datos para el entrenamiento
Ahora que hemos descargado el conjunto de datos a nuestro notebook como un DataFrame de Pandas, podemos realizar un procesamiento previo y dividirlo en conjuntos de entrenamiento y de prueba.
Primero, quitemos las filas con valores nulos del conjunto de datos y redistribuyamos 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. Dado que is_male es un valor booleano, lo convertiremos en un número entero para que todas las entradas de nuestro modelo sean numéricas:
labels = df['weight_pounds']
data = df.drop(columns=['weight_pounds'])
data['is_male'] = data['is_male'].astype(int)
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.
4. Inicializa Git.
AI Platform Notebooks tiene una integración directa con Git, por lo que puedes controlar las versiones directamente en tu entorno de notebook. Esto admite la confirmación de código directamente en la IU del notebook o a través de la terminal disponible en JupyterLab. En esta sección, inicializaremos un repositorio de Git en nuestro notebook y realizaremos nuestra primera confirmación a través de la IU.
Paso 1: Inicializa un repositorio de Git
En el directorio de tu codelab, selecciona Git y, luego, Init en la barra de menú superior de JupyterLab:
Cuando se te pregunte si quieres convertir este directorio en un repositorio de Git, selecciona Yes. Luego, selecciona el ícono de Git en la barra lateral izquierda para ver el estado de tus archivos y confirmaciones:
Paso 2: Realiza tu primera confirmación
En esta IU, puedes agregar archivos a una confirmación, consultar las diferencias de archivos (hablaremos de eso más adelante) y confirmar los cambios. Comencemos confirmando el archivo de notebook que acabamos de agregar.
Marca la casilla junto a tu archivo de notebook demo.ipynb a fin de almacenarlo en etapa intermedia para la confirmación (puedes ignorar el directorio .ipynb_checkpoints/). Ingresa un mensaje de confirmación en el cuadro de texto y, luego, haz clic en la marca de verificación para confirmar los cambios:
Ingresa tu nombre y correo electrónico cuando se te solicite. Luego, regresa a la pestaña Historial para ver tu primera confirmación:
Ten en cuenta que es posible que las capturas de pantalla no coincidan exactamente con tu IU debido a las actualizaciones posteriores a la publicación de este lab.
5. Crea y entrena un modelo de TensorFlow
Usaremos el conjunto de datos de natalidad de BigQuery que descargamos en nuestro notebook para crear un modelo que prediga el peso de los bebés. En este lab, nos enfocaremos en las herramientas del notebook, en lugar de la exactitud del modelo en sí.
Paso 1: Divide tus datos en conjuntos de entrenamiento y prueba
Usaremos la utilidad train_test_split de scikit-learn para dividir nuestros datos antes de compilar el modelo:
x,y = data,labels
x_train,x_test,y_train,y_test = train_test_split(x,y)
Ya está todo listo para compilar el modelo de TensorFlow.
Paso 2: Crea y entrena el modelo de TensorFlow
Compilaremos este modelo con la API del modelo Sequential de tf.keras, que nos permite definir nuestro modelo como una pila de capas. Todo el código que necesitamos para compilar nuestro modelo se encuentra aquí:
model = Sequential([
Dense(64, activation='relu', input_shape=(len(x_train.iloc[0]),)),
Dense(32, activation='relu'),
Dense(1)]
)
Luego, compilaremos el modelo para entrenarlo. Aquí elegiremos el optimizador, la función de pérdida y las métricas del modelo que queremos que el modelo registre durante el entrenamiento. Dado que este es un modelo de regresión (que predice un valor numérico), estamos usando el error cuadrático medio en lugar de la exactitud como nuestra métrica:
model.compile(optimizer=tf.keras.optimizers.RMSprop(),
loss=tf.keras.losses.MeanSquaredError(),
metrics=['mae', 'mse'])
Puedes usar la función model.summary() práctica de Keras para ver la forma y la cantidad de parámetros entrenables de tu modelo en cada capa.
Ahora estamos listos para entrenar nuestro modelo. Lo único que debemos hacer es llamar al método fit() y pasarle los datos de entrenamiento y las etiquetas. Aquí usaremos el parámetro de validación_split opcional, que retendrá una parte de los datos de entrenamiento para validar el modelo en cada paso. Lo ideal sería ver que el entrenamiento y la pérdida de validación ambas disminuyan. Sin embargo, recuerda que, en este ejemplo, nos enfocamos más en las herramientas de modelos y notebooks que en la calidad del modelo:
model.fit(x_train, y_train, epochs=10, validation_split=0.1)
Paso 3: Genera predicciones con ejemplos de prueba
Para ver el rendimiento de nuestro modelo, generemos algunas predicciones de prueba con los primeros 10 ejemplos del conjunto de datos de prueba.
num_examples = 10
predictions = model.predict(x_test[:num_examples])
Luego, iteraremos las predicciones de nuestro modelo y las compararemos con el valor real:
for i in range(num_examples):
print('Predicted val: ', predictions[i][0])
print('Actual val: ',y_test.iloc[i])
print()
Paso 4: Usa git diff y confirma tus cambios
Ahora que hiciste algunos cambios en el notebook, puedes probar la función git diff disponible en la IU de Git de Notebooks. El notebook demo.ipynb ahora debería aparecer en "Changed" (Cambiados). en la sección de la IU. Coloca el cursor sobre el nombre del archivo y haz clic en el ícono de diferencias:
Deberías poder ver una diferencia de tus cambios, como la siguiente:
Esta vez confirmaremos nuestros cambios a través de la línea de comandos con Terminal. En el menú Git de la barra de menú superior de JupyterLab, selecciona Git Command in Terminal. Si tienes abierta la pestaña de Git de la barra lateral izquierda mientras ejecutas los siguientes comandos, podrás ver tus cambios reflejados en la IU de Git.
En tu nueva instancia de terminal, ejecuta el siguiente comando para almacenar en etapa intermedia el archivo de notebook para la confirmación:
git add demo.ipynb
Luego, ejecuta el siguiente comando para confirmar los cambios (puedes usar el mensaje de confirmación que desees):
git commit -m "Build and train TF model"
Deberías ver la confirmación más reciente en el historial:
6. Usa la Herramienta What-If directamente desde tu notebook
La Herramienta What-If es una interfaz visual interactiva diseñada para ayudarte a visualizar tus conjuntos de datos y comprender mejor los resultados de tus modelos de AA. Es una herramienta de código abierto creada por el equipo PAIR de Google. Si bien funciona con cualquier tipo de modelo, tiene algunas funciones compiladas exclusivamente para AI Platform de Cloud.
La Herramienta What-If viene preinstalada en instancias de AI Platform Notebooks de Cloud con TensorFlow. Aquí los usaremos para ver el rendimiento general de nuestro modelo y para inspeccionar su comportamiento en datos de nuestro conjunto de prueba.
Paso 1: Prepara datos para la Herramienta What-If
Para aprovechar al máximo la Herramienta What-If, le enviaremos ejemplos de nuestro conjunto de prueba junto con las etiquetas de verdad fundamental de esos ejemplos (y_test). De esa manera, podemos comparar lo que nuestro modelo predijo con la verdad fundamental. Ejecuta la siguiente línea de código para crear un nuevo DataFrame con nuestros ejemplos de prueba y sus etiquetas:
wit_data = pd.concat([x_test, y_test], axis=1)
En este lab, conectaremos la Herramienta What-If al modelo que acabamos de entrenar en nuestro notebook. Para ello, debemos escribir una función que la herramienta usará para ejecutar estos datos de prueba en nuestro modelo:
def custom_predict(examples_to_infer):
preds = model.predict(examples_to_infer)
return preds
Paso 2: Crea una instancia de la Herramienta What-If
Crearemos una instancia de la Herramienta What-If pasando 500 ejemplos del conjunto de datos de prueba concatenado y las etiquetas de verdad fundamental que acabamos de crear. Creamos una instancia de WitConfigBuilder para configurar la herramienta y pasarle nuestros datos, la función de predicción personalizada que definimos anteriormente, junto con nuestro objetivo (lo que estamos prediciendo) y el tipo de modelo:
config_builder = (WitConfigBuilder(wit_data[:500].values.tolist(), data.columns.tolist() + ['weight_pounds'])
.set_custom_predict_fn(custom_predict)
.set_target_feature('weight_pounds')
.set_model_type('regression'))
WitWidget(config_builder, height=800)
Cuando se cargue la Herramienta What-If, deberías ver algo como esto:
En el eje X, puedes ver los datos de prueba distribuidos por el valor de peso previsto del modelo, weight_pounds.
Paso 3: Explora el comportamiento del modelo con la Herramienta What-If
Hay muchas cosas geniales que puedes hacer con la Herramienta What-If. A continuación, solo exploraremos algunos de ellos. Primero, veamos el editor de datos. Puedes seleccionar cualquier dato para ver sus atributos y cambiar sus valores. Para comenzar, haz clic en cualquier dato:
A la izquierda, verás los valores de los atributos del dato que seleccionaste. También puedes comparar la etiqueta de verdad fundamental de ese dato con el valor que predijo el modelo. En la barra lateral izquierda, también puedes cambiar los valores de los atributos y volver a ejecutar la predicción del modelo para ver el efecto que este cambio tuvo en tu modelo. Por ejemplo, podemos cambiar gestation_weeks a 30 para este dato haciendo doble clic en él para volver a ejecutar la predicción:
Usando los menús desplegables en la sección de diagrama de la Herramienta What-If, puedes crear todo tipo de visualizaciones personalizadas. Por ejemplo, aquí hay un gráfico con los modelos peso predicho en el eje X, edad de la madre en el eje Y y puntos coloreados por su error de inferencia (más oscuro significa una diferencia mayor entre el peso predicho y el real). Aquí parece que, a medida que disminuye el peso, el error del modelo aumenta ligeramente:
A continuación, marca el botón Partial agent plots a la izquierda. Esto muestra cómo influye cada atributo en la predicción del modelo. Por ejemplo, a medida que aumenta el tiempo de gestación, el peso previsto del bebé de nuestro modelo también aumenta:
Para obtener más ideas de exploración con la Herramienta What-If, consulta los vínculos que aparecen al comienzo de esta sección.
7. Conecta tu repositorio de Git local a GitHub (opcional)
Por último, aprenderemos a conectar el repositorio de Git de nuestra instancia de notebook a un repositorio de nuestra cuenta de GitHub. Si quieres realizar este paso, necesitarás una cuenta de GitHub.
Paso 1: Crea un repositorio nuevo en GitHub
En tu cuenta de GitHub, crea un repositorio nuevo. Asígnale un nombre y una descripción, decide si quieres que sea público y selecciona Crear repositorio (no es necesario que lo inicialices con un archivo README). En la página siguiente, seguirás las instrucciones para enviar un repositorio existente desde la línea de comandos.
Abre una ventana de Terminal y agrega tu nuevo repositorio como recurso remoto. Reemplaza username en la siguiente URL del repositorio por tu nombre de usuario de GitHub y your-repo por el nombre que acabas de crear:
git remote add origin git@github.com:username/your-repo.git
Paso 2: Autentícate en GitHub en tu instancia de notebooks
A continuación, deberás autenticarte en GitHub desde tu instancia de notebook. Este proceso varía en función de si habilitaste la autenticación de dos factores en GitHub.
Si no sabes por dónde empezar, sigue los pasos de la documentación de GitHub para crear una clave SSH y, luego, agrega la nueva clave a GitHub.
Paso 3: Asegúrate de que vinculaste correctamente tu repositorio de GitHub
Para asegurarte de que realizaste la configuración correctamente, ejecuta git remote -v en tu terminal. Deberías ver tu nuevo repositorio en la lista como remoto. Una vez que veas la URL de tu repositorio de GitHub y te hayas autenticado en GitHub desde tu notebook, podrás enviarla directamente a GitHub desde tu instancia de notebook.
Para sincronizar el repositorio de Git de tu notebook local con el repositorio de GitHub recién creado, haz clic en el botón de carga en la nube, en la parte superior de la barra lateral de Git:
Actualiza tu repositorio de GitHub. Deberías ver el código de tu notebook con tus confirmaciones anteriores. Si otras personas tienen acceso a tu repositorio de GitHub y quieres ver los cambios más recientes en tu notebook, haz clic en el ícono de descarga en la nube para sincronizar esos cambios.
En la pestaña History de la IU de Git de Notebooks, puedes ver si tus confirmaciones locales están sincronizadas con GitHub. En este ejemplo, origin/master se corresponde con nuestro repositorio en GitHub:
Cada vez que realices confirmaciones nuevas, vuelve a hacer clic en el botón de carga a la nube para enviar esos cambios a tu repositorio de GitHub.
8. ¡Felicitaciones!
Hiciste mucho en este lab 👏👏👏
Para recapitular, aprendiste a hacer lo siguiente:
- Crea una instancia de notebook de AI Platform personalizada
- Inicializa un repositorio de Git local en esa instancia, agrega confirmaciones a través de la IU de Git o la línea de comandos y consulta las diferencias de Git en la IU de Git del notebook.
- Crea y entrena un modelo simple de TensorFlow 2
- Usa la Herramienta What-If en tu instancia de notebook
- Conecta tu repositorio de Git de notebook a un repositorio externo en GitHub
9. 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.