1. Descripción general
En este lab, se te explicarán 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
- Hacer 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, la red 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 del 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 cualquier otro nombre que quieras.
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 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.
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 la niña, y la información demográfica de los padres del bebé. Usaremos un subconjunto de las características para predecir el peso de nacimiento de un bebé.
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 es de 21 GB y contiene 123 millones de filas. Para que sea sencillo, 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 nuestro modelo predecirá). El conjunto de datos abarca 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 de nuestro conjunto de datos, ejecuta el siguiente comando:
df.describe()
Aquí se muestran la media, la desviación estándar, el mínimo y otras métricas de nuestras columnas numéricas. Por último, obtengamos algunos datos de nuestra columna booleana que indiquen el género 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 un 50/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 reordenemos los datos:
df = df.dropna()
df = shuffle(df, random_state=2)
A continuación, extrae la columna de etiqueta en una variable independiente y crea un DataFrame con solo 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 las cuatro características que usaremos para el entrenamiento.
4. Inicializa git
AI Platform Notebooks tiene una integración directa con git, por lo que puedes realizar el control de 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 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 (hablaremos de esto más adelante) y confirmar los cambios. Comencemos por confirmar el archivo de notebook que acabamos de agregar.
Marca la casilla junto al 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 de los bebés. En este lab, nos enfocaremos en las herramientas de notebooks, en lugar de la precisión 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 el modelo:
x,y = data,labels
x_train,x_test,y_train,y_test = train_test_split(x,y)
Ya tenemos todo listo para compilar nuestro modelo de TensorFlow.
Paso 2: Compila y entrena el modelo de TensorFlow
Crearemos este modelo con la API del modelo Sequential de tf.keras, que nos permite definir nuestro modelo como una pila de capas. Aquí está todo el código que necesitamos para compilar nuestro modelo:
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 queremos que registre durante el entrenamiento. Como este es 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.
Ya tenemos todo listo para entrenar nuestro modelo. Todo lo que tenemos que hacer es llamar al método fit() y pasarle nuestros datos de entrenamiento y etiquetas. Aquí, usaremos el parámetro opcional validation_split, que contendrá una parte de nuestros datos de entrenamiento para validar el modelo en cada paso. Lo ideal es que veas que la pérdida de entrenamiento y la de validación disminuyen. 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 en ejemplos de prueba
Para ver el rendimiento de nuestro modelo, generemos algunas predicciones de prueba en los primeros 10 ejemplos de nuestro conjunto de datos de prueba.
num_examples = 10
predictions = model.predict(x_test[:num_examples])
Luego, iteraremos sobre 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 los 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 estar en la sección "Changed" de la IU. Coloca el cursor sobre el nombre del archivo y haz clic en el ícono de diferencia:
Con eso, deberías poder ver una diferencia de tus cambios, como la siguiente:
Esta vez, confirmaremos los 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 la pestaña de git de la barra lateral izquierda abierta mientras ejecutas los siguientes comandos, podrás ver tus 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 los cambios (puedes usar el mensaje de confirmación que quieras):
git commit -m "Build and train TF model"
Luego, deberías ver tu 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 compiladas exclusivamente para Cloud AI Platform.
La herramienta What-If viene preinstalada en las instancias de Notebooks de Cloud AI Platform con TensorFlow. Aquí lo usaremos para ver el rendimiento general de nuestro modelo y para inspeccionar su comportamiento en los datos de nuestro conjunto de prueba.
Paso 1: Prepara los datos para la herramienta Qué pasaría si
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 esta manera, podremos comparar lo que nuestro modelo predijo con la verdad fundamental. Ejecuta la siguiente línea de código para crear un DataFrame nuevo 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 pasándole 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)
Deberías ver algo como esto cuando se cargue la herramienta Qué pasaría si:
En el eje x, puedes ver los datos de prueba distribuidos según el valor de peso previsto del modelo, weight_pounds.
Paso 3: Explora el comportamiento del modelo con la Herramienta What-If
Hay muchas funciones interesantes que puedes hacer con la herramienta Qué pasaría si. Aquí exploraremos solo algunas de ellas. Primero, veamos el editor de datos. Puedes seleccionar cualquier dato para ver sus atributos y cambiar sus valores. Para comenzar, haz clic en cualquier punto de datos:
A la izquierda, verás los valores de los atributos para el 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 tuvo este cambio en tu modelo. Por ejemplo, podemos cambiar gestation_weeks a 30 para este dato haciendo doble clic en él y volviendo a ejecutar la predicción:
Con los menús desplegables de la sección de trama de la herramienta Qué pasaría si, puedes crear todo tipo de visualizaciones personalizadas. Por ejemplo, este es un gráfico con el peso previsto de los modelos en el eje x, la edad de la madre en el eje y y los puntos coloreados según su error de inferencia (cuanto más oscuro, mayor es la diferencia entre el peso previsto 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:
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. Opcional: Conecta tu repositorio 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. Asóciale 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 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 aparece 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 que se indican en 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 haber configurado todo correctamente, ejecuta git remote -v en la terminal. Deberías ver tu repositorio nuevo como remoto. Una vez que veas la URL de tu repositorio de GitHub y te hayas autenticado en GitHub desde tu notebook, estará todo listo para enviar directamente a GitHub desde tu instancia de notebook.
Para sincronizar el repositorio de Git de tu 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 repositorio de GitHub y deseas descargar los cambios más recientes en tu notebook, haz clic en el ícono de descarga de la nube para sincronizarlos.
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 repositorio 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 de git o la línea de comandos, y consulta las diferencias de git en la IU de git de Notebook
- Compila y entrena un modelo simple de TensorFlow 2
- Usa la Herramienta What-If en tu instancia de Notebook
- Conecta tu repositorio de Notebook de Git 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 tus recursos de modelos.