GSP631

Descripción general

TensorFlow es una biblioteca de aprendizaje automático (AA) potente, portátil y de código abierto. Fue desarrollada por Google y puede trabajar con conjuntos de datos de gran tamaño. En este lab, crearás y entrenarás un modelo de visión artificial para reconocer diferentes prendas de vestir usando Vertex AI Workbench de TensorFlow.

Introducción a TensorFlow

TensorFlow ofrece un marco de trabajo computacional para crear modelos de AA. Ofrece una variedad de kits de herramientas diferentes que te permiten crear modelos con el nivel de abstracción que prefieras. En este lab, usarás tf.keras, una API de alto nivel para crear y entrenar una red neuronal para clasificar imágenes en TensorFlow.

Redes neuronales

Una red neuronal es un modelo inspirado en el cerebro. Se compone de capas, de las cuales al menos una está oculta, que consiste en unidades o neuronas simples conectadas seguidas de no linealidades.

Un nodo de una red neuronal generalmente recibe varios valores de entrada y genera un solo valor de salida. La neurona aplica una función de activación (transformación no lineal) a una suma ponderada de valores de entrada para calcular el valor de salida.

Para obtener más información sobre las redes neuronales, consulta Redes neuronales: estructura.

Objetivos

En este lab, aprenderás a hacer lo siguiente:

• Diseñar, compilar, entrenar y evaluar un modelo de TensorFlow
• Guardar y cargar modelos
• Escribir tus propias devoluciones de llamada para personalizar el comportamiento durante el entrenamiento
• Completar una serie de ejercicios para guiarte por la experimentación con las diferentes capas de la red

Configuración y requisitos

Antes de hacer clic en el botón Comenzar lab

Lee estas instrucciones. Los labs son cronometrados y no se pueden pausar. El cronómetro, que comienza a funcionar cuando haces clic en Comenzar lab, indica por cuánto tiempo tendrás a tu disposición los recursos de Google Cloud.

Este lab práctico te permitirá realizar las actividades correspondientes en un entorno de nube real, no en uno de simulación o demostración. Para ello, se te proporcionan credenciales temporales nuevas que utilizarás para acceder a Google Cloud durante todo el lab.

Para completar este lab, necesitarás lo siguiente:

• Acceso a un navegador de Internet estándar (se recomienda el navegador Chrome)

Nota: Usa una ventana de navegador privada o de Incógnito para ejecutar este lab. Así evitarás cualquier conflicto entre tu cuenta personal y la cuenta de estudiante, lo que podría generar cargos adicionales en tu cuenta personal.

• Tiempo para completar el lab: Recuerda que, una vez que comienzas un lab, no puedes pausarlo.

Nota: Si ya tienes un proyecto o una cuenta personal de Google Cloud, no los uses en este lab para evitar cargos adicionales en tu cuenta.

Tarea 1. Abre el notebook en Vertex AI Workbench

1. En el menú de navegación de la consola de Google Cloud, haz clic en Vertex AI > Workbench.

2. Busca la instancia y haz clic en el botón Abrir JupyterLab.

La interfaz de JupyterLab para tu instancia de Workbench se abrirá en una pestaña nueva del navegador.

Instala TensorFlow y paquetes adicionales

1. En el menú Selector, en Otro, selecciona Terminal.

2. Comprueba si tu entorno de Python ya está configurado. Copia y pega el siguiente comando en la terminal.

python --version

Resultado de ejemplo:

Python 3.10.14

3. Ejecuta el siguiente comando para instalar el paquete de TensorFlow.

pip3 install tensorflow

4. Para actualizar pip3, ejecuta el siguiente comando en la terminal.

pip3 install --upgrade pip

Pylint es una herramienta que verifica si hay errores en el código de Python y destaca problemas sintácticos y estilísticos en tu código fuente de ese lenguaje.

5. Ejecuta el siguiente comando para instalar el paquete de pylint.

pip install -U pylint --user

6. Instala los paquetes requeridos para el lab en el archivo requirements.txt:

pip install -r requirements.txt

Ahora, tu entorno está configurado.

Tarea 2. Crea un notebook nuevo y, luego, importa bibliotecas

1. Haz clic en el ícono del signo + a la izquierda de Workbench para abrir un nuevo Selector.

2. En el menú Selector, en Notebook, selecciona Python3.

Se te presentará un nuevo notebook de Jupyter. Para obtener más información sobre cómo usar notebooks de Jupyter, consulta la documentación de notebooks de Jupyter.

3. Importa y configura logging y google-cloud-logging para Cloud Logging. En la primera celda, agrega el siguiente código:

# Import and configure logging import logging import google.cloud.logging as cloud_logging from google.cloud.logging.handlers import CloudLoggingHandler from google.cloud.logging_v2.handlers import setup_logging cloud_logger = logging.getLogger('cloudLogger') cloud_logger.setLevel(logging.INFO) cloud_logger.addHandler(CloudLoggingHandler(cloud_logging.Client())) cloud_logger.addHandler(logging.StreamHandler())

4. Importa tensorflow para entrenar y evaluar el modelo. Llámalo tf para facilitar su uso. Agrega el siguiente código a la primera celda.

# Import TensorFlow import tensorflow as tf

5. Importa numpy, para analizar los datos para depuración. Llámalo np para facilitar su uso. Agrega el siguiente código a la primera celda.

# Import numpy import numpy as np

6. Agrega el siguiente código a la primera celda para importar tensorflow_datasets para integrar el conjunto de datos. TensorFlow Datasets es una colección de conjuntos de datos listos para usar con TensorFlow.

Para obtener más información sobre cómo usarlo, consulta la guía y la lista de conjuntos de datos. # Import tensorflow_datasets import tensorflow_datasets as tfds

7. Para ejecutar la celda, haz clic en el botón Ejecutar o presiona Mayúsculas + Intro.

8. Guarda el notebook. Haz clic en Archivo -> Guardar. Asígnale al archivo el nombre model.ipynb y haz clic en Aceptar.

Tarea 3. Carga y procesa el conjunto de datos previamente

Acerca del conjunto de datos

Entrenarás una red neuronal para clasificar imágenes de indumentaria de un conjunto de datos llamado Fashion MNIST.

Este conjunto de datos tiene 70,000 prendas de indumentaria que pertenecen a 10 categorías diferentes de indumentaria. Las imágenes muestran artículos individuales de indumentaria en baja resolución (28 por 28 píxeles), como se observa aquí:

En este lab, se usarán 60,000 imágenes para entrenar la red y 10,000 para evaluar con qué precisión la red aprendió a clasificar las imágenes.

Los datos de Fashion MNIST están disponibles en tensorflow datasets(tfds).

Cómo cargar el conjunto de datos

Para cargar los datos de Fashion MNIST, deberás usar la función tfds.load().

1. Agrega el siguiente código a la segunda celda en el notebook:

# Define, load and configure data (ds_train, ds_test), info = tfds.load('fashion_mnist', split=['train', 'test'], with_info=True, as_supervised=True)

En el código anterior, configuraste el argumento split para especificar qué divisiones del conjunto de datos se cargarán. Estableciste as_supervised en True para garantizar que el tf.data.Dataset cargado tenga una estructura de 2 tuplas (input, label).

ds_train y ds_test son del tipo tf.data.Dataset. ds_train tiene 60,000 imágenes que se usarán para entrenar el modelo. ds_test tiene 10,000 imágenes que se usarán para evaluarlo.

Para leer más información sobre tfds.load() y sus argumentos, consulta la guía.

¿Qué aspecto tienen estos valores?

2. A continuación, agrega sentencias de impresión para ver los valores mínimos y máximos de las imágenes de entrenamiento para el elemento 0. Agrega el siguiente código a la segunda celda:

# Values before normalization image_batch, labels_batch = next(iter(ds_train)) print("Before normalization ->", np.min(image_batch[0]), np.max(image_batch[0]))

Procesamiento previo de los datos

1. Tamaño del lote es un término que se usa en el aprendizaje automático y se refiere a la cantidad de ejemplos de entrenamiento utilizados en una iteración. Establecerás este término en un valor de 32.

Especifica el tamaño del lote agregando el siguiente código model.ipynb:

# Define batch size BATCH_SIZE = 32

2. Cuando se entrena una red neuronal, por varias razones es más sencillo si escalas los valores de píxeles al rango entre 0 y 1. Este proceso se conoce como 'normalización'. Puesto que los valores de píxeles para el conjunto de datos FashionMNIST están en el rango de [0, 255], dividirás los valores de píxeles por 255.0 para normalizar las imágenes.

El código que se ofrece a continuación usa la función map() de tf.data.Dataset para aplicar la normalización a imágenes en ds_train y ds_test. Como los valores de píxeles son del tipo tf.uint8, la función tf.cast se usa para convertirlos en tf.float32 y, luego, dividirlos por 255.0. El conjunto de datos también se convierte en lotes llamando al método batch() con BATCH_SIZE como argumento.

Lee más información sobre los métodos disponibles para tf.data.Dataset aquí.

Agrega el siguiente código al final del archivo:

# Normalize and batch process the dataset ds_train = ds_train.map(lambda x, y: (tf.cast(x, tf.float32)/255.0, y)).batch(BATCH_SIZE) ds_test = ds_test.map(lambda x, y: (tf.cast(x, tf.float32)/255.0, y)).batch(BATCH_SIZE)

3. Vuelve a imprimir los valores mínimo y máximo de una imagen en el conjunto de datos de entrenamiento:

Agrega el siguiente código al final del archivo:

# Examine the min and max values of the batch after normalization image_batch, labels_batch = next(iter(ds_train)) print("After normalization ->", np.min(image_batch[0]), np.max(image_batch[0]))

Tarea 4. Diseña, compila y entrena el modelo

En esta sección, diseñarás tu modelo usando TensorFlow.

1. Agrega el siguiente código al archivo:

# Define the model model = tf.keras.models.Sequential([tf.keras.layers.Flatten(), tf.keras.layers.Dense(64, activation=tf.nn.relu), tf.keras.layers.Dense(10, activation=tf.nn.softmax)])

Mira los diferentes tipos de capas y los parámetros usados en la arquitectura del modelo:

• Sequential: Define una SECUENCIA de capas en una red neuronal.

• Flatten: Nuestras imágenes son de forma (28, 28), es decir, los valores están en forma de matriz cuadrada. Flatten toma ese cuadrado y lo convierte en un vector de una dimensión.

• Dense: Agrega una capa de neuronas.

Cada capa de neuronas requiere una función de activación para decidir si una neurona debe activarse o no. Hay muchas opciones, pero este lab usa las siguientes.

• Relu significa, en la práctica, que X>0 devuelve X, si no, devuelve 0. Esta opción pasa valores 0 o superiores a la siguiente capa en la red.
• Softmax toma un conjunto de valores y efectivamente selecciona el más grande para que no tengas que ordenarlos a fin de encontrar el mayor valor. Por ejemplo, si el resultado de la última capa se ve así [0.1, 0.1, 0.05, 0.1, 9.5, 0.1, 0.05, 0.05, 0.05], esta devuelve [0,0,0,0,1,0,0,0,0].

Compila y entrena el modelo

En esta sección, primero compilarás tu modelo con un optimizador y una función de pérdida. Luego, entrenarás el modelo con tus datos y etiquetas de entrenamiento.

El objetivo es que el modelo determine la relación entre los datos de entrenamiento y sus etiquetas. Una vez que se completa el entrenamiento, se recomienda que tu modelo vea imágenes nuevas de indumentaria que se parezca a tus datos de entrenamiento y haga predicciones sobre a qué clase de indumentaria pertenecen.

Un optimizador es uno de los dos argumentos requeridos para compilar un modelo tf.keras. Un Optimizer es un algoritmo que modifica los atributos de la red neuronal, como las ponderaciones y la tasa de aprendizaje. Esto ayuda a reducir la pérdida y a mejorar la exactitud.

Lee más información sobre los diferentes tipos de optimizadores disponibles en tf.keras aquí.

Loss indica el rendimiento del modelo con un número. Si el modelo tiene un mejor rendimiento, la pérdida será un número pequeño. De lo contrario, será uno grande.

Lee más información sobre los diferentes tipos de funciones de pérdida disponibles en tf.keras aquí.

Observa el parámetro metrics=. Esto le permite a TensorFlow informar sobre la exactitud del entrenamiento después de cada ciclo de entrenamiento comparando los resultados predichos con las respuestas conocidas (etiquetas). Básicamente, vuelve a informar sobre qué tan eficazmente progresa el entrenamiento.

Haz clic aquí para obtener más detalles sobre los diferentes tipos de métricas disponibles en `tf.keras`

Model.fit entrenará el modelo durante una cantidad fija de ciclos de entrenamiento.

1. Agrega el siguiente código al archivo:

# Compile the model model.compile(optimizer = tf.keras.optimizers.Adam(), loss = tf.keras.losses.SparseCategoricalCrossentropy(), metrics=[tf.keras.metrics.SparseCategoricalAccuracy()]) model.fit(ds_train, epochs=5)

Haz clic en Revisar mi progreso para verificar el objetivo. Crear modelos de aprendizaje automático

Ejecuta el código

1. Para ejecutar la segunda celda, haz clic en el botón Ejecutar o presiona Mayúsculas + Intro.

Cuando la celda del notebook se ejecute, verás la información sobre la pérdida y la exactitud después de cada ciclo (o pase) de entrenamiento. Observa que con cada ciclo de entrenamiento (o pase), la exactitud sube:

Resultado de ejemplo (tus valores pueden ser un poco diferentes, así que ignora cualquier mensaje de advertencia):

Before normalization -> 0 227 After normalization -> 0.0 1.0 Epoch 1/5 1875/1875 [==============================] - 12s 6ms/step - loss: 0.5264 - sparse_categorical_accuracy: 0.8175 Epoch 2/5 1875/1875 [==============================] - 6s 3ms/step - loss: 0.3977 - sparse_categorical_accuracy: 0.8580 Epoch 3/5 1875/1875 [==============================] - 5s 3ms/step - loss: 0.3585 - sparse_categorical_accuracy: 0.8701 Epoch 4/5 1875/1875 [==============================] - 5s 2ms/step - loss: 0.3329 - sparse_categorical_accuracy: 0.8784 Epoch 5/5 1875/1875 [==============================] - 5s 2ms/step - loss: 0.3151 - sparse_categorical_accuracy: 0.8846

Para el resultado # Values before normalization, observarás que los valores mínimo y máximo están en el rango de[0, 255]. Después de la normalización, puedes ver que todos los valores están en el rango de [0, 1].

A medida que avanza el entrenamiento, la pérdida disminuye y la exactitud aumenta.

Cuando el modelo ya termine de entrenarse, verás un valor de exactitud al final del último ciclo de entrenamiento. Podría estar cerca de 0.8864 como se ve arriba (tu exactitud puede ser distinta).

Esto te indica que la red neuronal tiene una precisión de aproximadamente un 89% en la clasificación de datos de entrenamiento. En otras palabras, determinó una coincidencia de patrones entre la imagen y las etiquetas que funcionó un 89% del tiempo. No es excelente, pero tampoco es deficiente si consideramos que solo se entrenó durante cinco ciclos en una red neuronal pequeña.

Tarea 5. Evalúa el rendimiento del modelo en datos no vistos

Pero ¿cómo tendrá rendimiento el modelo en los datos que no vio?

El conjunto de prueba puede ayudar a responder esta pregunta. Llama a model.evaluate, pasa los dos conjuntos y este informa la pérdida de cada uno.

Evalúa el conjunto de prueba:

1. Agrega el siguiente código a la tercera celda en el notebook:

cloud_logger.info(model.evaluate(ds_test))

2. Para ejecutar la celda, haz clic en el botón Ejecutar o presiona Mayúsculas + Intro.

Si te desplazas hasta el final, podrás ver el resultado de la evaluación en la última línea.

Before normalization -> 0 227 After normalization -> 0.0 1.0 Epoch 1/5 1875/1875 [==============================] - 12s 6ms/step - loss: 0.5264 - sparse_categorical_accuracy: 0.8175 Epoch 2/5 1875/1875 [==============================] - 6s 3ms/step - loss: 0.3977 - sparse_categorical_accuracy: 0.8580 Epoch 3/5 1875/1875 [==============================] - 5s 3ms/step - loss: 0.3585 - sparse_categorical_accuracy: 0.8701 Epoch 4/5 1875/1875 [==============================] - 5s 2ms/step - loss: 0.3329 - sparse_categorical_accuracy: 0.8784 Epoch 5/5 1875/1875 [==============================] - 5s 2ms/step - loss: 0.3151 - sparse_categorical_accuracy: 0.8846 313/313 [==============================] - 1s 4ms/step - loss: 0.3653 - sparse_categorical_accuracy: 0.8708 INFO:cloudLogger:[0.36530008912086487, 0.8708000183105469]

El modelo informa una precisión de 0.8708 en el conjunto de prueba(ds_test), lo que significa que su exactitud fue de cerca de un 87% (tus valores pueden ser un poco diferentes).

Como se esperaba, el modelo no es tan preciso con los datos desconocidos como lo fue con los que se entrenó.

A medida que ahondes en TensorFlow, aprenderás sobre maneras de mejorar esto.

Haz clic en Revisar mi progreso para verificar el objetivo. Usa el modelo

Tarea 6. Guarda y carga el modelo

El avance del modelo se puede guardar durante el entrenamiento y después de este. Esto significa que un modelo puede reanudarse desde el punto en el que quedó y evitar largos momentos de entrenamiento. Si guardas el modelo también podrás compartirlo y otras personas podrán recrear tu trabajo. Para este primer ejercicio, agregarás el código necesario para guardar y cargar tu modelo.

Se puede guardar un modelo entero en dos formatos de archivo diferentes (SavedModel y Keras). El formato TensorFlow SavedModel es el formato de archivo predeterminado en TF2.x. Sin embargo, los modelos se pueden guardar en el formato Keras. Obtendrás más información para guardar modelos en los dos formatos de archivo.

1. Agrega el siguiente código a la cuarta celda en el notebook:

# Save the entire model as a SavedModel. model.save('saved_model') # Reload a fresh Keras model from the saved model new_model = tf.keras.models.load_model('saved_model') # Summary of loaded SavedModel new_model.summary() # Save the entire model to a keras file. model.save('my_model.keras') # Recreate the exact same model, including its weights and the optimizer new_model_keras = tf.keras.models.load_model('my_model.keras') # Summary of loaded keras model new_model_keras.summary()

En el código anterior, se muestra cómo guardar el modelo en dos formatos diferentes y volver a cargar el modelo guardado. Puedes elegir cualquier formato según tu caso de uso. Puedes leer más respecto de esta función en la Documentación de TensorFlow de "Guarda y carga modelos".

2. Para ejecutar la celda, haz clic en el botón Ejecutar o presiona Mayúsculas + Intro.

Al final del resultado, verás dos conjuntos de resúmenes de modelo. En el primero, se muestra el resumen después de que se guarda el modelo en el formato SavedModel. En el segundo, se muestra el resumen después de que el modelo se guarda en el formato h5.

Puedes ver que ambos resúmenes de modelo son idénticos, ya que, en efecto, guardamos el mismo modelo en dos formatos diferentes.

Model: "sequential" _________________________________________________________________ Layer (type) Output Shape Param # ================================================================= flatten (Flatten) (None, 784) 0 dense (Dense) (None, 64) 50240 dense_1 (Dense) (None, 10) 650 ================================================================= Total params: 50,890 Trainable params: 50,890 Non-trainable params: 0 _________________________________________________________________ Model: "sequential" _________________________________________________________________ Layer (type) Output Shape Param # ================================================================= flatten (Flatten) (None, 784) 0 dense (Dense) (None, 64) 50240 dense_1 (Dense) (None, 10) 650 ================================================================= Total params: 50,890 Trainable params: 50,890 Non-trainable params: 0 _________________________________________________________________

Haz clic en Revisar mi progreso para verificar el objetivo. Guardar y cargar modelos

Tarea 7. Explora las devoluciones de llamada

Anteriormente cuando entrenaste el modelo, habrás notado que, a medida que avanzaba el entrenamiento, la pérdida del modelo disminuía y la exactitud aumentaba. Una vez que lograste la exactitud y pérdida del entrenamiento deseadas, puede que de todas formas hayas tenido que esperar un poco antes de que se completara el entrenamiento.

Tal vez hayas pensado: "¿No sería mejor si pudiera detener el entrenamiento cuando el modelo alcance el valor de exactitud deseado?".

Por ejemplo, si una exactitud del 95% es suficientemente buena y el modelo logra eso después de 3 ciclos de entrenamiento, ¿por qué esperar hasta que se completen muchos más ciclos?

La respuesta son las devoluciones de llamada.

Una devolución de llamada es una herramienta potente para personalizar el comportamiento de un modelo Keras durante el entrenamiento, la evaluación o la inferencia. Puedes definir una devolución de llamada para dejar de entrenar el modelo tan pronto este alcance una exactitud deseada en el conjunto de entrenamiento.

Prueba el siguiente código para ver qué sucede cuando defines una devolución de llamada para detener el entrenamiento cuando la exactitud alcanza un 84%:

1. Abre el Selector y elige Python3 para crear un nuevo notebook de Jupyter.

2. Guarda el archivo como callback_model.ipynb.

3. Pega el siguiente código en la primera celda de callback_model.ipynb:

# Import and configure logging import logging import google.cloud.logging as cloud_logging from google.cloud.logging.handlers import CloudLoggingHandler from google.cloud.logging_v2.handlers import setup_logging exp_logger = logging.getLogger('expLogger') exp_logger.setLevel(logging.INFO) exp_logger.addHandler(CloudLoggingHandler(cloud_logging.Client(), name="callback")) # Import tensorflow_datasets import tensorflow_datasets as tfds # Import numpy import numpy as np # Import TensorFlow import tensorflow as tf # Define Callback class myCallback(tf.keras.callbacks.Callback): def on_epoch_end(self, epoch, logs={}): if(logs.get('sparse_categorical_accuracy')>0.84): exp_logger.info("\nReached 84% accuracy so cancelling training!") self.model.stop_training = True callbacks = myCallback() # Define, load and configure data (ds_train, ds_test), info = tfds.load('fashion_mnist', split=['train', 'test'], with_info=True, as_supervised=True) # Define batch size BATCH_SIZE = 32 # Normalizing and batch processing of data ds_train = ds_train.map(lambda x, y: (tf.cast(x, tf.float32)/255.0, y)).batch(BATCH_SIZE) ds_test = ds_test.map(lambda x, y: (tf.cast(x, tf.float32)/255.0, y)).batch(BATCH_SIZE) # Define the model model = tf.keras.models.Sequential([tf.keras.layers.Flatten(), tf.keras.layers.Dense(64, activation=tf.nn.relu), tf.keras.layers.Dense(10, activation=tf.nn.softmax)]) # Compile data model.compile(optimizer = tf.keras.optimizers.Adam(), loss = tf.keras.losses.SparseCategoricalCrossentropy(), metrics=[tf.keras.metrics.SparseCategoricalAccuracy()]) model.fit(ds_train, epochs=5, callbacks=[callbacks])

4. Presiona Ctrl + S o ve a Archivo > Save Notebook, para guardar los cambios.

5. Para ejecutar el código, haz clic en el botón Ejecutar o presiona Mayúsculas + Intro.

Observa que el entrenamiento se canceló después de unos cuantos ciclos.

Haz clic en Revisar mi progreso para verificar el objetivo. Explorar las devoluciones de llamada

Tarea 8. Experimenta con el modelo

En esta sección, experimentarás con las distintas capas de la red.

Ejercicio 1

En este ejercicio, explorarás las capas de tu modelo. ¿Qué ocurre cuando cambias la cantidad de neuronas?

1. Abre el Selector y elige Python3 para crear un nuevo notebook de Jupyter.

2. Guarda el archivo como updated_model.ipynb.

3. Pega el siguiente código en la primera celda de updated_model.ipynb:

# Import and configure logging import logging import google.cloud.logging as cloud_logging from google.cloud.logging.handlers import CloudLoggingHandler from google.cloud.logging_v2.handlers import setup_logging up_logger = logging.getLogger('upLogger') up_logger.setLevel(logging.INFO) up_logger.addHandler(CloudLoggingHandler(cloud_logging.Client(), name="updated")) # Import tensorflow_datasets import tensorflow_datasets as tfds # Import numpy import numpy as np # Import TensorFlow import tensorflow as tf # Define, load and configure data (ds_train, ds_test), info = tfds.load('fashion_mnist', split=['train', 'test'], with_info=True, as_supervised=True) # Define batch size BATCH_SIZE = 32 # Normalizing and batch processing of data ds_train = ds_train.map(lambda x, y: (tf.cast(x, tf.float32)/255.0, y)).batch(BATCH_SIZE) ds_test = ds_test.map(lambda x, y: (tf.cast(x, tf.float32)/255.0, y)).batch(BATCH_SIZE) # Define the model model = tf.keras.models.Sequential([tf.keras.layers.Flatten(), tf.keras.layers.Dense(64, activation=tf.nn.relu), tf.keras.layers.Dense(10, activation=tf.nn.softmax)]) # Compile data model.compile(optimizer = tf.keras.optimizers.Adam(), loss = tf.keras.losses.SparseCategoricalCrossentropy(), metrics=[tf.keras.metrics.SparseCategoricalAccuracy()]) model.fit(ds_train, epochs=5) # Logs model summary model.summary(print_fn=up_logger.info)

4. Experimenta con diferentes valores para la capa densa.

Ve a la sección # Define the model, cambia 64 por 128 neuronas:

# Define the model model = tf.keras.models.Sequential([tf.keras.layers.Flatten(), tf.keras.layers.Dense(128, activation=tf.nn.relu), tf.keras.layers.Dense(10, activation=tf.nn.softmax)])

4. Presiona Ctrl + S o ve a Archivo > Save Notebook, para guardar los cambios.

5. Para ejecutar el código, haz clic en el botón Ejecutar o presiona Mayúsculas + Intro.

¿Qué resultados diferentes obtienes para pérdida, tiempo de entrenamiento, etc.? ¿Por qué crees que pasa eso?

Cuando aumentas la cantidad de neuronas a 128, debes realizar más cálculos. Esto enlentece el proceso de entrenamiento. En este caso, el aumento tuvo un impacto positivo porque el modelo es más preciso. Pero no siempre se aplica esta lógica de "más es mejor". Puedes caer bajo los efectos de la ley de los rendimientos decrecientes muy rápido.

Haz clic en Revisar mi progreso para verificar el objetivo. Ejercicio 1

Ejercicio 2

Considera los efectos de las capas adicionales de la red. ¿Qué pasará si agregas otra capa entre las dos capas densas?

1. En updated_model.ipynb, agrega una capa en la sección # Define the model.

Reemplaza la definición de tu modelo por lo siguiente:

# Define the model model = tf.keras.models.Sequential([tf.keras.layers.Flatten(), tf.keras.layers.Dense(64, activation=tf.nn.relu), tf.keras.layers.Dense(64, activation=tf.nn.relu), tf.keras.layers.Dense(10, activation=tf.nn.softmax)])

2. Presiona Ctrl + S o ve a Archivo > Save Notebook, para guardar los cambios.

3. Para ejecutar el código, haz clic en el botón Ejecutar o presiona Mayúsculas + Intro.

Respuesta: No hay un impacto significativo porque estos datos son relativamente simples. En el caso de datos más complejos, a menudo son necesarias capas adicionales.

Haz clic en Revisar mi progreso para verificar el objetivo. Ejercicio 2

Ejercicio 3

Antes de entrenar tu modelo, normalizaste los valores de píxeles en el rango de [0, 1]. ¿Cuál sería el impacto de quitar la normalización para que los valores estén en el rango de [0, 255], como lo estaban originalmente en el conjunto de datos?

1. Pruébalo. En la sección # Define, load and configure data, quita la función de asignación aplicada a los conjuntos de datos de entrenamiento y de prueba.

# Define, load and configure data (ds_train, ds_test), info = tfds.load('fashion_mnist', split=['train', 'test'], with_info=True, as_supervised=True) # Define batch size BATCH_SIZE = 32 # Normalizing and batch processing of data ds_train = ds_train.batch(BATCH_SIZE) ds_test = ds_test.batch(BATCH_SIZE) # Define the model model = tf.keras.models.Sequential([tf.keras.layers.Flatten(), tf.keras.layers.Dense(64, activation=tf.nn.relu), tf.keras.layers.Dense(10, activation=tf.nn.softmax)])

2. Agrega este código al final de la celda para imprimir el valor máximo de la primera imagen en el lote 0. Sin la normalización, el valor máximo estará en el rango de [0, 255].

# Print out max value to see the changes image_batch, labels_batch = next(iter(ds_train)) t_image_batch, t_labels_batch = next(iter(ds_test)) up_logger.info("training images max " + str(np.max(image_batch[0]))) up_logger.info("test images max " + str(np.max(t_image_batch[0])))

3. Tu modelo final updated_model.ipynb se verá de esta forma:

# Import and configure logging import logging import google.cloud.logging as cloud_logging from google.cloud.logging.handlers import CloudLoggingHandler from google.cloud.logging_v2.handlers import setup_logging up_logger = logging.getLogger('upLogger') up_logger.setLevel(logging.INFO) up_logger.addHandler(CloudLoggingHandler(cloud_logging.Client(), name="updated")) # Import tensorflow_datasets import tensorflow_datasets as tfds # Import numpy import numpy as np # Import TensorFlow import tensorflow as tf # Define, load and configure data (ds_train, ds_test), info = tfds.load('fashion_mnist', split=['train', 'test'], with_info=True, as_supervised=True) # Define batch size BATCH_SIZE = 32 # Normalizing and batch processing of data ds_train = ds_train.batch(BATCH_SIZE) ds_test = ds_test.batch(BATCH_SIZE) # Define the model model = tf.keras.models.Sequential([tf.keras.layers.Flatten(), tf.keras.layers.Dense(64, activation=tf.nn.relu), tf.keras.layers.Dense(10, activation=tf.nn.softmax)]) # Compile data model.compile(optimizer = tf.keras.optimizers.Adam(), loss = tf.keras.losses.SparseCategoricalCrossentropy(), metrics=[tf.keras.metrics.SparseCategoricalAccuracy()]) model.fit(ds_train, epochs=5) # Logs model summary model.summary(print_fn=up_logger.info) # Print out max value to see the changes image_batch, labels_batch = next(iter(ds_train)) t_image_batch, t_labels_batch = next(iter(ds_test)) up_logger.info("training images max " + str(np.max(image_batch[0]))) up_logger.info("test images max " + str(np.max(t_image_batch[0])))

4. Presiona Ctrl + S o ve a Archivo > Save Notebook, para guardar los cambios.

5. Para ejecutar el código, haz clic en el botón Ejecutar o presiona Mayúsculas + Intro.

El resultado esperado para # Print out max value to see the changes

INFO:upLogger:training images max 255 INFO:upLogger:test images max 255

Después de completar los ciclos de entrenamiento, puedes ver la diferencia en la exactitud sin la normalización.

¿Por qué crees que cambia la exactitud?

Hay una gran respuesta aquí en Stack Overflow.

Haz clic en Revisar mi progreso para verificar el objetivo. Ejercicio 3

Ejercicio 4

¿Qué ocurre si quitas la capa Flatten() y por qué?

Adelante, pruébalo.

1. En la sección # Define the model, quita tf.keras.layers.Flatten():

# Define the model model = tf.keras.models.Sequential([tf.keras.layers.Dense(64, activation=tf.nn.relu), tf.keras.layers.Dense(10, activation=tf.nn.softmax)])

2. Guarda y ejecuta la celda en updated_model.ipynb.

Recibes un error sobre la forma de los datos. Esta situación es esperable.

Los detalles del error pueden parecer poco claros en este momento, pero esto refuerza la regla general de que la primera capa de tu red debe tener la misma forma que tus datos. Ahora mismo, las imágenes de la entrada tienen la forma 28×28 y 28 capas de 28 neuronas no sería factible. Por eso, tiene más sentido nivelar ese valor 28,28 a 784×1.

En lugar de escribir todo el código para manejar esto por tu cuenta, puedes agregar la capa Flatten() al principio. Cuando los arrays se carguen en el modelo más adelante, se nivelarán automáticamente por ti.

Ejercicio 5

Observa la capa (resultado) final. ¿Por qué hay 10 neuronas en esa capa? ¿Qué ocurre si tienes una cantidad distinta de 10?

Descúbrelo entrenando la red con 5.

1. Reemplaza la sección # Define the model por lo siguiente para deshacer el cambio que realizaste en la sección previa.

# Define the model model = tf.keras.models.Sequential([tf.keras.layers.Flatten(), tf.keras.layers.Dense(64, activation=tf.nn.relu), tf.keras.layers.Dense(10, activation=tf.nn.softmax)])

2. Cambia la cantidad de neuronas de la última capa de 10 a 5:

# Define the model model = tf.keras.models.Sequential([tf.keras.layers.Flatten(), tf.keras.layers.Dense(64, activation=tf.nn.relu), tf.keras.layers.Dense(5, activation=tf.nn.softmax)])

3. Guarda y ejecuta la celda en updated_model.ipynb.

Qué ocurre: recibes un error apenas encuentra un valor imprevisto.

Otra regla general indica que la cantidad de neuronas de la última capa debe coincidir con la cantidad de clases para las que estás realizando la clasificación.. En este caso, son los dígitos del 0 al 9, por lo que hay 10 de ellas y deberías tener 10 neuronas en tu capa final.

¡Felicitaciones!

¡Felicitaciones! En este lab, aprendiste a diseñar, compilar, entrenar y evaluar un modelo de TensorFlow. También aprendiste a guardar y cargar modelos, y a escribir tus propias devoluciones de llamada para personalizar el comportamiento durante el entrenamiento. Asimismo, completaste una serie de ejercicios para guiarte por la experimentación con diferentes capas de la red.

Próximos pasos/Más información

• Consulta todo lo que hay que saber en el Curso intensivo de aprendizaje automático.
• Diviértete en la página Pruébala para tener una idea de qué puedes hacer con la visión artificial.
• Consulta el aprendizaje automático como parte de Vertex AI. Para ello revisa la Documentación de Vertex AI.
• Actividades divertidas con la IA. Consulta Experiments with Google.
• Obtén más información sobre TensorFlow.

Capacitación y certificación de Google Cloud

Recibe la formación que necesitas para aprovechar al máximo las tecnologías de Google Cloud. Nuestras clases incluyen habilidades técnicas y recomendaciones para ayudarte a avanzar rápidamente y a seguir aprendiendo. Para que puedas realizar nuestros cursos cuando más te convenga, ofrecemos distintos tipos de capacitación de nivel básico a avanzado: a pedido, presenciales y virtuales. Las certificaciones te ayudan a validar y demostrar tus habilidades y tu conocimiento técnico respecto a las tecnologías de Google Cloud.

Actualización más reciente del manual: 12 de septiembre de 2024

Prueba más reciente del lab: 12 de septiembre de 2024

Copyright 2024 Google LLC. All rights reserved. Google y el logotipo de Google son marcas de Google LLC. Los demás nombres de productos y empresas pueden ser marcas de las respectivas empresas a las que estén asociados.