1. Descripción general
En este lab, se te guiará por varias herramientas de AI Platform Notebooks para explorar tus datos y crear prototipos de modelos de AA.
Qué aprenderá
Aprenderás a hacer lo siguiente:
- Crea y personaliza una instancia de AI Platform Notebooks
- Realizar 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 TensorFlow 2 Enterprise más reciente sin GPUs:
Asigna un nombre a tu instancia o usa el predeterminado. Luego, exploraremos las opciones de personalización. Haz clic en el botón Personalizar:
AI Platform Notebooks tiene muchas opciones de personalización diferentes, como la región en la que se implementa tu instancia, el tipo de imagen, el tamaño de la máquina, la cantidad de GPUs 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 cree la instancia, verás una marca de verificación verde junto a ella en la IU de Notebooks. Selecciona Abrir JupyterLab para abrir tu instancia y comenzar a crear prototipos:
Cuando abras la instancia, crea un directorio nuevo llamado codelab. Este es el directorio desde el que trabajaremos durante este lab:
Haz doble clic en el directorio codelab que acabas de crear y, luego, selecciona el notebook de Python 3 en el selector:
Cambia el nombre del notebook a demo.ipynb o al nombre que quieras darle.
Paso 4: Importa paquetes de Python
Crea una celda nueva 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 datos de BigQuery a tu notebook
BigQuery, el almacén de macrodatos de Google Cloud, puso a disposición del público muchos conjuntos de datos para que los explores. AI Platform Notebooks admite la integración directa con BigQuery sin necesidad de autenticación.
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 o niña y la información demográfica de sus padres. Usaremos un subconjunto de las características para predecir el peso de un bebé al nacer.
Paso 1: Descarga 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.
Paso 2: Prepara el conjunto de datos para el entrenamiento
Ahora que descargamos el conjunto de datos en 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 mezclémoslos:
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. Como 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 los cuatro atributos que usaremos para el entrenamiento.
4. Inicializa Git
AI Platform Notebooks se integra directamente con Git, por lo que puedes controlar las versiones directamente en tu entorno de notebook. Esto permite confirmar 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 del codelab, selecciona Git y, luego, Init en la barra de menú superior de JupyterLab:
Cuando te pregunte si deseas convertir este directorio en un repositorio de Git, selecciona Sí. 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, ver las diferencias entre archivos (lo veremos más adelante) y confirmar tus cambios. Comencemos por confirmar el archivo de notebook que acabamos de agregar.
Marca la casilla junto a tu archivo de notebook demo.ipynb para prepararlo 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, vuelve 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 que se realizaron desde que se publicó este lab.
5. Compila 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 del bebé. En este lab, nos enfocaremos en las herramientas de notebooks, en lugar de la exactitud del modelo en sí.
Paso 1: Divide tus datos en conjuntos de entrenamiento y de prueba
Usaremos la utilidad train_test_split de Scikit Learn para dividir nuestros datos antes de compilar nuestro modelo:
x,y = data,labels
x_train,x_test,y_train,y_test = train_test_split(x,y)
Ahora ya podemos compilar nuestro modelo de TensorFlow.
Paso 2: Compila y entrena el modelo de TensorFlow
Compilaremos este modelo con la API de modelos 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 nuestro modelo para poder entrenarlo. Aquí elegiremos el optimizador, la función de pérdida y las métricas del modelo que nos gustaría que el modelo registrara durante el entrenamiento. Dado que se trata de un modelo de regresión (que predice un valor numérico), usamos el error cuadrático medio en lugar de la exactitud como métrica:
model.compile(optimizer=tf.keras.optimizers.RMSprop(),
loss=tf.keras.losses.MeanSquaredError(),
metrics=['mae', 'mse'])
Puedes usar la práctica función model.summary() de Keras para ver la forma y la cantidad de parámetros entrenables de tu modelo en cada capa.
Ahora ya podemos entrenar nuestro modelo. Todo lo que debemos hacer es llamar al método fit() y pasarle nuestros datos y etiquetas de entrenamiento. Aquí usaremos el parámetro opcional validation_split, que retendrá una parte de nuestros datos de entrenamiento para validar el modelo en cada paso. Lo ideal es que la pérdida de entrenamiento y la pérdida de validación ambas disminuyan. Sin embargo, recuerda que, en este ejemplo, nos enfocamos más en las herramientas del modelo y el notebook que en la calidad del modelo:
model.fit(x_train, y_train, epochs=10, validation_split=0.1)
Paso 3: Genera predicciones sobre ejemplos de prueba
Para ver el rendimiento de nuestro modelo, generemos algunas predicciones de prueba sobre los primeros 10 ejemplos de nuestro 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 realizaste 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 la sección "Cambiado" de la IU. Coloca el cursor sobre el nombre del archivo y haz clic en el ícono de diferencias:
Con eso, deberías poder ver una comparación de tus cambios, como la siguiente:
Esta vez, confirmaremos nuestros cambios a través de la línea de comandos con la 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 los cambios reflejados en la IU de Git.
En la nueva instancia de la terminal, ejecuta el siguiente comando para preparar el archivo de notebook para la confirmación:
git add demo.ipynb
Luego, ejecuta el siguiente comando para confirmar tus cambios (puedes usar el mensaje de confirmación que quieras):
git commit -m "Build and train TF model"
Luego, 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 el resultado de tus modelos de AA. Es una herramienta de código abierto creada por el equipo de PAIR de Google. Si bien funciona con cualquier tipo de modelo, tiene algunas funciones creadas exclusivamente para Cloud AI Platform.
La herramienta de comparaciones se encuentra preinstalada en las instancias de Cloud AI Platform Notebooks con TensorFlow. Aquí, lo usaremos para ver el rendimiento general de nuestro modelo y analizar su comportamiento en los puntos de datos de nuestro conjunto de datos de prueba.
Paso 1: Prepara los datos para la Herramienta de simulación
Para aprovechar al máximo la herramienta de análisis hipotético, le enviaremos ejemplos de nuestro conjunto de prueba junto con las etiquetas de verdad fundamental de esos ejemplos (y_test). De esa manera, podremos comparar lo que predijo nuestro modelo 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 puntos de 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 de análisis hipotético
Instanciaremos la Herramienta de ajuste del modelo 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, pasando 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)
Deberías ver algo como esto cuando se cargue la herramienta de Comparación de situaciones:
En el eje X, puedes ver los puntos de datos de prueba distribuidos según el valor de peso predicho del modelo, weight_pounds.
Paso 3: Explora el comportamiento del modelo con la Herramienta What-If
Hay muchas cosas interesantes que puedes hacer con la herramienta de Comparación. Aquí exploraremos solo algunas de ellas. Primero, veamos el editor de puntos de datos. Puedes seleccionar cualquier punto de datos para ver sus atributos y cambiar los valores de los atributos. Para comenzar, haz clic en cualquier punto de datos:
A la izquierda, verás los valores de los atributos del punto de datos que seleccionaste. También puedes comparar la etiqueta de verdad fundamental de ese punto de datos 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 tuvo este cambio en tu modelo. Por ejemplo, podemos cambiar gestation_weeks a 30 para este punto de datos haciendo doble clic en él y volviendo a ejecutar la predicción:
Con los menús desplegables de la sección de gráficos de la herramienta de comparativas, puedes crear todo tipo de visualizaciones personalizadas. Por ejemplo, aquí se muestra un gráfico con el peso predicho de los modelos en el eje X, la edad de la madre en el eje Y y puntos coloreados según su error de inferencia (los colores más oscuros indican una mayor diferencia 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 Gráficos de dependencia parcial a la izquierda. Esto muestra cómo cada atributo influye en la predicción del modelo. Por ejemplo, a medida que aumenta el tiempo de gestación, también aumenta el peso del bebé que predice nuestro modelo:
Si quieres obtener más ideas para explorar con la herramienta de comparaciones, consulta los vínculos al comienzo de esta sección.
7. Opcional: Conecta tu repo de Git local a GitHub
Por último, aprenderemos a conectar el repositorio de Git en nuestra instancia de notebook a un repositorio en 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. Asigna 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 README). En la siguiente página, seguirás las instrucciones para enviar un repositorio existente desde la línea de comandos.
Abre una ventana de la terminal y agrega tu repositorio nuevo como remoto. Reemplaza username en la URL del repositorio que se muestra a continuación por tu nombre de usuario de GitHub y your-repo por el nombre del 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 según si tienes habilitada 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 llave SSH y, luego, agregar la llave nueva a GitHub.
Paso 3: Asegúrate de haber vinculado correctamente tu repo de GitHub
Para asegurarte de que configuraste todo correctamente, ejecuta git remote -v en la terminal. Deberías ver tu nuevo repositorio como remoto. Una vez que veas la URL de tu repositorio de GitHub y te hayas autenticado en GitHub desde tu notebook, podrás enviar contenido directamente a GitHub desde tu instancia de notebook.
Para sincronizar tu repositorio de Git de notebook local con el repositorio de GitHub que acabas de crear, haz clic en el botón de carga en la nube que se encuentra en la parte superior de la barra lateral de Git:
Actualiza tu repositorio de GitHub y deberías ver el código de tu notebook con tus confirmaciones anteriores. Si otras personas tienen acceso a tu repo de GitHub y quieres extraer los cambios más recientes en tu notebook, haz clic en el ícono de descarga de la nube para sincronizar esos cambios.
En la pestaña Historial de la IU de Git de Notebooks, puedes ver si tus confirmaciones locales están sincronizadas con GitHub. En este ejemplo, origin/master corresponde a nuestro repo en GitHub:
Cada vez que realices confirmaciones nuevas, vuelve a hacer clic en el botón de carga en la nube para enviar esos cambios a tu repositorio de GitHub.
8. ¡Felicitaciones!
Hiciste mucho en este lab 👏👏👏
En resumen, aprendiste a hacer lo siguiente:
- Crea y personaliza una instancia de AI Platform Notebooks
- Inicializa un repositorio de Git local en esa instancia, agrega confirmaciones a través de la IU o la línea de comandos de Git, y visualiza las diferencias de Git en la IU de Git de Notebook.
- Crea y entrena un modelo simple de TensorFlow 2
- Usa la Herramienta What-If en tu instancia de notebook
- Conecta tu repo de Git de Notebook a un repositorio externo en GitHub
9. 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.