2.2 Construcción, Entrenamiento y Ajuste Fino de Redes Neuronales en TensorFlow

En esta sección integral, profundizaremos en los detalles de la construcción de redes neuronales utilizando la API Keras de TensorFlow, una interfaz poderosa y fácil de usar para construir modelos de aprendizaje profundo. Exploraremos el proceso de entrenamiento de estas redes en conjuntos de datos del mundo real, permitiéndoles aprender patrones complejos y hacer predicciones precisas.

Además, investigaremos técnicas avanzadas para afinar el rendimiento del modelo, centrándonos en mejorar la precisión y la capacidad de generalización. El sólido marco de TensorFlow simplifica estas tareas complejas al ofrecer un conjunto de métodos intuitivos para la creación, compilación y entrenamiento de modelos, así como herramientas sofisticadas para la optimización de hiperparámetros.

Nuestro viaje comenzará con la construcción de una arquitectura básica de red neuronal, pasando por las etapas de preparación de datos, entrenamiento del modelo y evaluación del rendimiento. Luego avanzaremos hacia técnicas más sofisticadas, demostrando cómo aprovechar las capacidades de TensorFlow para ajustar los hiperparámetros, implementar estrategias de regularización y optimizar la arquitectura del modelo. A través de ejemplos prácticos e ideas útiles, obtendrás una comprensión profunda de cómo aprovechar todo el potencial de TensorFlow para crear modelos de aprendizaje profundo altamente eficientes y precisos.

2.2.1 Construcción de un Modelo de Red Neuronal

Al construir una red neuronal, el primer paso crucial es definir la arquitectura del modelo. Este proceso implica especificar cuidadosamente las capas y determinar cómo fluye la información a través de ellas. La arquitectura actúa como el plano para tu red neuronal, dictando su estructura y capacidad para aprender a partir de los datos de entrada.

Para este propósito, utilizaremos la API Secuencial proporcionada por TensorFlow. Esta API poderosa e intuitiva te permite construir redes neuronales apilando capas de forma lineal. La API Secuencial es especialmente adecuada para construir redes neuronales feedforward, donde la información fluye en una dirección, desde la capa de entrada a través de las capas ocultas hasta la capa de salida.

La API Secuencial ofrece varias ventajas clave que la convierten en una opción popular para la construcción de redes neuronales:

Simplicidad e intuición: Proporciona un enfoque sencillo, capa por capa, para la construcción de modelos, lo que la hace especialmente accesible para principiantes e ideal para la creación rápida de prototipos de arquitecturas de redes neuronales.
Mayor legibilidad: La estructura lineal de los modelos Secuenciales da lugar a arquitecturas claras y fácilmente interpretables, lo que facilita la comprensión, depuración y modificación del diseño de la red.
Versatilidad dentro de los límites: A pesar de su aparente simplicidad, la API Secuencial admite la creación de una amplia gama de arquitecturas de redes neuronales, desde perceptrones multicapa básicos hasta diseños más sofisticados que incorporan capas convolucionales o recurrentes, abarcando una amplia gama de tareas de aprendizaje automático.
Desarrollo eficiente de modelos: El enfoque simplificado de la API permite iteraciones rápidas y experimentación, lo que permite a los desarrolladores probar y refinar rápidamente diferentes configuraciones de modelos sin la necesidad de procedimientos de configuración complejos.
Integración fluida: Los modelos secuenciales se integran sin problemas con otros componentes de TensorFlow y Keras, lo que facilita los procesos de compilación, entrenamiento y evaluación dentro del flujo de trabajo de aprendizaje profundo.

Al utilizar la API Secuencial, puedes experimentar fácilmente con diferentes configuraciones de capas, funciones de activación y otras opciones arquitectónicas para optimizar el rendimiento de tu modelo para la tarea específica que tienes entre manos.

Definición de un Modelo Secuencial

Una arquitectura típica de red neuronal está compuesta por varios componentes clave, cada uno de los cuales desempeña un papel crucial en el proceso de aprendizaje:

Capa de Entrada

Esta es la primera capa de la red, que actúa como la puerta de entrada para que los datos sin procesar ingresen a la red neuronal. Es responsable de recibir y procesar inicialmente los datos de entrada. En tareas de clasificación de imágenes, cada neurona en esta capa generalmente corresponde a un píxel en la imagen de entrada. Por ejemplo, en una imagen de 28x28 píxeles, la capa de entrada tendría 784 neuronas (28 * 28 = 784). Esta capa no realiza ningún cálculo; en su lugar, transfiere los datos a las capas siguientes para su procesamiento.

Capas Ocultas

Estas son las capas intermedias situadas entre la capa de entrada y la capa de salida. Se denominan "ocultas" porque sus valores no son directamente observables a partir de las entradas o salidas de la red. Las capas ocultas son el núcleo de la red neuronal, ya que realizan transformaciones complejas sobre los datos de entrada. A través de estas transformaciones, la red aprende a representar patrones y características complejas en los datos.

El número de capas ocultas y neuronas en cada capa puede variar según la complejidad de la tarea. Por ejemplo, una tarea simple podría requerir solo una capa oculta con unas pocas neuronas, mientras que tareas más complejas, como el reconocimiento de imágenes o el procesamiento del lenguaje natural, podrían necesitar múltiples capas ocultas con cientos o miles de neuronas cada una. La elección de las funciones de activación en estas capas (como ReLU, sigmoide o tanh) también desempeña un papel crucial en la capacidad de la red para aprender relaciones no lineales en los datos.

Capa de Salida

Esta es la última capa de la red, responsable de producir la predicción o clasificación de la red. La estructura de esta capa está directamente relacionada con la naturaleza del problema que se está resolviendo. En tareas de clasificación, el número de neuronas en esta capa generalmente corresponde al número de clases en el problema. Por ejemplo, en una tarea de reconocimiento de dígitos (0-9), la capa de salida tendría 10 neuronas, cada una representando un dígito.

La función de activación de esta capa se elige según el tipo de problema: softmax para clasificación multiclase, sigmoide para clasificación binaria o una activación lineal para tareas de regresión. La salida de esta capa representa la decisión o predicción de la red, que luego se puede interpretar según el contexto específico del problema.

Para ilustrar estos conceptos, consideremos la construcción de una red neuronal para una tarea de clasificación específica utilizando el conjunto de datos MNIST. Este conjunto de datos es una colección de 70,000 imágenes en escala de grises de dígitos escritos a mano (0-9), cada una de 28x28 píxeles. Es ampliamente utilizado como referencia en tareas de aprendizaje automático y visión por computadora. Así es como podría verse nuestra arquitectura de red para esta tarea:

Capa de Entrada: 784 neuronas (28x28 píxeles aplanados)
Capas Ocultas: Una o más capas, por ejemplo, 128 neuronas en la primera capa oculta, 64 en la segunda
Capa de Salida: 10 neuronas (una para cada clase de dígito 0-9)

Esta arquitectura permite que la red aprenda características de las imágenes de entrada, las procese a través de las capas ocultas y finalmente produzca una distribución de probabilidad sobre las 10 posibles clases de dígitos en la capa de salida.

Ejemplo: Definición de una Red Neuronal Simple

import tensorflow as tf
from tensorflow.keras.models import Sequential
from tensorflow.keras.layers import Dense, Flatten, Dropout
from tensorflow.keras.datasets import mnist
import matplotlib.pyplot as plt

# Load and preprocess the MNIST dataset
(X_train, y_train), (X_test, y_test) = mnist.load_data()
X_train, X_test = X_train / 255.0, X_test / 255.0  # Normalize pixel values to [0, 1]

# Build a Sequential neural network
model = Sequential([
    Flatten(input_shape=(28, 28)),  # Flatten 28x28 images to a 1D vector of 784 elements
    Dense(128, activation='relu'),  # Hidden layer with 128 neurons and ReLU activation
    Dropout(0.2),                   # Dropout layer for regularization
    Dense(64, activation='relu'),   # Second hidden layer with 64 neurons and ReLU
    Dropout(0.2),                   # Another dropout layer
    Dense(10, activation='softmax') # Output layer for 10 classes (digits 0-9)
])

# Compile the model
model.compile(optimizer='adam',
              loss='sparse_categorical_crossentropy',
              metrics=['accuracy'])

# Display model architecture
model.summary()

# Train the model
history = model.fit(X_train, y_train, epochs=10, batch_size=32, validation_split=0.2, verbose=1)

# Evaluate the model
test_loss, test_accuracy = model.evaluate(X_test, y_test, verbose=0)
print(f"Test accuracy: {test_accuracy:.4f}")

# Plot training history
plt.figure(figsize=(12, 4))
plt.subplot(1, 2, 1)
plt.plot(history.history['accuracy'], label='Training Accuracy')
plt.plot(history.history['val_accuracy'], label='Validation Accuracy')
plt.title('Model Accuracy')
plt.xlabel('Epoch')
plt.ylabel('Accuracy')
plt.legend()

plt.subplot(1, 2, 2)
plt.plot(history.history['loss'], label='Training Loss')
plt.plot(history.history['val_loss'], label='Validation Loss')
plt.title('Model Loss')
plt.xlabel('Epoch')
plt.ylabel('Loss')
plt.legend()

plt.tight_layout()
plt.show()

Desglose del código:

Importación de bibliotecas:
- Importamos TensorFlow y los módulos necesarios de Keras.
- Se importa matplotlib para fines de visualización.
Carga y preprocesamiento de datos:
- El conjunto de datos MNIST se carga utilizando mnist.load_data().
- Los datos de entrada (imágenes) se normalizan dividiéndolos por 255, escalando los valores de píxeles al rango [0, 1].
Construcción del modelo:
- Utilizamos la API Secuencial para crear una pila lineal de capas.
- La arquitectura del modelo es la siguiente:
  a. Capa Flatten: Convierte imágenes de 28x28 en vectores 1D de 784 elementos.
  b. Capa Densa (128 neuronas): Primera capa oculta con activación ReLU.
  c. Capa Dropout (tasa del 20%): Para regularización, ayuda a prevenir sobreajuste.
  d. Capa Densa (64 neuronas): Segunda capa oculta con activación ReLU.
  e. Otra capa Dropout (tasa del 20%): Mayor regularización.
  f. Capa Densa (10 neuronas): Capa de salida con activación softmax para clasificación de 10 clases.
Compilación del modelo:
- Optimizador: Adam (algoritmo de optimización de tasa de aprendizaje adaptativa).
- Función de pérdida: Entropía cruzada categórica escasa (adecuada para etiquetas enteras).
- Métrica: Precisión (para monitorear durante el entrenamiento y evaluación).
Resumen del modelo:
- model.summary() muestra un resumen de la arquitectura del modelo, incluyendo el número de parámetros en cada capa y el número total de parámetros entrenables.
Entrenamiento del modelo:
- El modelo se entrena utilizando model.fit() con los siguientes parámetros:
  - 10 épocas (pasadas completas sobre los datos de entrenamiento).
  - Tamaño de lote de 32 (número de muestras procesadas antes de actualizar el modelo).
  - 20% de los datos de entrenamiento se utilizan para validación.
  - Modo detallado 1 para salida detallada del progreso.
Evaluación del modelo:
- El modelo entrenado se evalúa en el conjunto de prueba usando model.evaluate().
- Se imprime la precisión del conjunto de prueba para evaluar el rendimiento del modelo en datos no vistos.
Visualización del historial de entrenamiento:
- Se crean dos gráficos para visualizar el proceso de entrenamiento:
  a. Precisión del modelo: Muestra la precisión de entrenamiento y validación a lo largo de las épocas.
  b. Pérdida del modelo: Muestra la pérdida de entrenamiento y validación a lo largo de las épocas.
- Estos gráficos ayudan a entender el progreso del aprendizaje del modelo e identificar posibles sobreajustes o subajustes.

Este ejemplo proporciona una visión completa de todo el proceso de construcción, entrenamiento y evaluación de una red neuronal utilizando TensorFlow y Keras. Incluye el preprocesamiento de datos, la creación del modelo con capas de dropout para regularización, la compilación del modelo, el entrenamiento con validación, la evaluación en un conjunto de prueba y la visualización del historial de entrenamiento.

2.2.2 Compilación del modelo

Una vez definida la arquitectura del modelo, se debe compilar antes de entrenar. La compilación de un modelo es un paso crucial que configura el proceso de aprendizaje.

Involucra tres componentes clave:

Especificar el optimizador: El optimizador controla cómo el modelo actualiza sus pesos durante el entrenamiento. Es responsable de implementar el algoritmo de retropropagación, que calcula los gradientes de la función de pérdida con respecto a los parámetros del modelo. Los optimizadores populares incluyen Adam, SGD (descenso de gradiente estocástico) y RMSprop. Cada optimizador tiene sus propias características e hiperparámetros, como la tasa de aprendizaje, que pueden ajustarse para mejorar el rendimiento del modelo.
Definir la función de pérdida: La función de pérdida cuantifica la diferencia entre las predicciones del modelo y los valores reales del objetivo. Proporciona una medida de qué tan bien está funcionando el modelo durante el entrenamiento. La elección de la función de pérdida depende del tipo de problema que estás resolviendo. Por ejemplo, la entropía cruzada binaria se usa comúnmente para clasificación binaria, mientras que el error cuadrático medio se utiliza a menudo para tareas de regresión. El optimizador trabaja para minimizar esta función de pérdida durante el entrenamiento.
Especificar las métricas de evaluación: Las métricas de evaluación proporcionan formas adicionales de evaluar el rendimiento del modelo más allá de la función de pérdida. Estas métricas ofrecen información sobre cómo se está desempeñando el modelo en aspectos específicos de la tarea. Las métricas comunes incluyen la precisión para tareas de clasificación, el error absoluto medio para regresión y la puntuación F1 para problemas de clasificación desequilibrados. Se pueden especificar múltiples métricas para obtener una visión integral del rendimiento del modelo durante el entrenamiento y la evaluación.

Al elegir y configurar cuidadosamente estos componentes durante el paso de compilación, se establece la base para un entrenamiento efectivo del modelo. El proceso de compilación prepara esencialmente al modelo para aprender de los datos al definir cómo medirá su rendimiento (función de pérdida y métricas) y cómo mejorará con el tiempo (optimizador).

Ejemplo: Compilación de la red neuronal

# Import necessary libraries
import tensorflow as tf
from tensorflow.keras.models import Sequential
from tensorflow.keras.layers import Dense, Flatten
from tensorflow.keras.optimizers import Adam
from tensorflow.keras.losses import SparseCategoricalCrossentropy

# Define the model architecture
model = Sequential([
    Flatten(input_shape=(28, 28)),
    Dense(128, activation='relu'),
    Dense(64, activation='relu'),
    Dense(10, activation='softmax')
])

# Compile the model
model.compile(
    optimizer=Adam(learning_rate=0.001),  # Adam optimizer with custom learning rate
    loss=SparseCategoricalCrossentropy(),  # Loss function for multi-class classification
    metrics=['accuracy', tf.keras.metrics.Precision(), tf.keras.metrics.Recall()]  # Track multiple metrics
)

# Display model summary
model.summary()

Desglose del código:

Importación de bibliotecas:

Se importa TensorFlow y los módulos necesarios de Keras.
Las importaciones específicas del optimizador (Adam) y la función de pérdida (SparseCategoricalCrossentropy) se incluyen para mayor claridad.

Definición de la arquitectura del modelo:

Se crea un modelo Secuencial con una estructura de capas específica:
- Capa Flatten para convertir la entrada 2D (imágenes de 28x28) en 1D.
- Dos capas ocultas Densas con activación ReLU.
- Capa de salida Densa con activación softmax para clasificación multiclase.

Compilación del modelo:

El método compile se llama con tres componentes principales:
1. Optimizador: Se utiliza el optimizador Adam con una tasa de aprendizaje personalizada de 0.001.
2. Función de pérdida: SparseCategoricalCrossentropy, adecuada para clasificación multiclase con etiquetas enteras.
3. Métricas: Se rastrean múltiples métricas:
  - Precisión: Corrección general de las predicciones.
  - Precisión (Precision): Proporción de predicciones verdaderas positivas.
  - Recall: Proporción de positivos reales identificados correctamente.

Resumen del modelo:

Se llama al método summary() para mostrar la arquitectura del modelo, incluyendo detalles de las capas y el total de parámetros.

Este ejemplo proporciona una configuración para compilar un modelo de red neuronal. Incluye la configuración personalizada del optimizador, el uso explícito de la función de pérdida y métricas de evaluación adicionales. El resumen del modelo al final ofrece una visión general rápida de la estructura de la red, lo cual es crucial para comprender y depurar el modelo.

2.2.3 Entrenamiento del modelo

Después de compilar el modelo, puedes iniciar el proceso de entrenamiento utilizando la función fit(). Este paso crucial es donde el modelo aprende a partir de los datos proporcionados. El proceso de entrenamiento involucra varios componentes clave:

Paso hacia adelante (Forward Pass): En esta etapa inicial, los datos de entrada atraviesan la red capa por capa. Cada neurona dentro de la red aplica sus pesos específicos y su función de activación a la información entrante, generando una salida que se convierte en la entrada para la capa sucesiva. Este proceso permite que la red transforme progresivamente los datos de entrada a través de su estructura intrincada.
Cálculo de la pérdida: Al completar el paso hacia adelante, donde los datos han atravesado toda la red, las predicciones del modelo se comparan con los valores objetivo reales. La diferencia entre estos dos conjuntos de valores se cuantifica utilizando la función de pérdida predefinida. Este cálculo proporciona una métrica crucial, ofreciendo una visión del rendimiento actual del modelo y su precisión en las predicciones.
Retropropagación (Backpropagation): Este algoritmo sofisticado calcula el gradiente de la función de pérdida con respecto a cada peso individual dentro de la red. Al hacerlo, determina hasta qué punto cada peso contribuyó al error general en las predicciones del modelo. Este paso es fundamental para entender cómo ajustar la red para mejorar su rendimiento.
Actualización de pesos: Utilizando los gradientes calculados durante la retropropagación, el optimizador ajusta metódicamente los pesos en toda la red. Este proceso está guiado por el objetivo general de minimizar la función de pérdida, mejorando así las capacidades predictivas del modelo. El grado y la manera en que se realizan estos ajustes están determinados por el algoritmo de optimización específico elegido durante la compilación del modelo.
Iteración: Los pasos mencionados anteriormente - paso hacia adelante, cálculo de la pérdida, retropropagación y actualización de pesos - se ejecutan de manera iterativa para cada lote de datos dentro del conjunto de entrenamiento. Este proceso se repite luego durante el número especificado de épocas, lo que permite un refinamiento gradual y progresivo del rendimiento del modelo. Con cada iteración, el modelo tiene la oportunidad de aprender de una variedad de ejemplos, ajustando continuamente sus parámetros para adaptarse mejor a los patrones subyacentes en los datos.

A través de este proceso iterativo, el modelo aprende a reconocer patrones en los datos, ajustando sus parámetros internos para minimizar errores y mejorar sus capacidades predictivas. La función fit() automatiza este proceso complejo, facilitando el entrenamiento de redes neuronales sofisticadas para los desarrolladores.

Ejemplo: Entrenamiento del modelo en el conjunto de datos MNIST

import tensorflow as tf
from tensorflow.keras.datasets import mnist
from tensorflow.keras.models import Sequential
from tensorflow.keras.layers import Dense, Flatten, Dropout
from tensorflow.keras.optimizers import Adam
from tensorflow.keras.callbacks import EarlyStopping
import matplotlib.pyplot as plt

# Load MNIST dataset
(X_train, y_train), (X_test, y_test) = mnist.load_data()

# Normalize the input data to range [0, 1]
X_train, X_test = X_train / 255.0, X_test / 255.0

# Build the model
model = Sequential([
    Flatten(input_shape=(28, 28)),
    Dense(128, activation='relu'),
    Dropout(0.2),
    Dense(64, activation='relu'),
    Dropout(0.2),
    Dense(10, activation='softmax')
])

# Compile the model
model.compile(optimizer=Adam(learning_rate=0.001),
              loss='sparse_categorical_crossentropy',
              metrics=['accuracy'])

# Define early stopping
early_stopping = EarlyStopping(monitor='val_loss', patience=3, restore_best_weights=True)

# Train the model
history = model.fit(X_train, y_train, 
                    epochs=20, 
                    batch_size=32, 
                    validation_data=(X_test, y_test),
                    callbacks=[early_stopping])

# Evaluate the model
test_loss, test_accuracy = model.evaluate(X_test, y_test)
print(f"Test Accuracy: {test_accuracy:.4f}")

# Plot training history
plt.figure(figsize=(12, 4))
plt.subplot(1, 2, 1)
plt.plot(history.history['accuracy'], label='Training Accuracy')
plt.plot(history.history['val_accuracy'], label='Validation Accuracy')
plt.title('Model Accuracy')
plt.xlabel('Epoch')
plt.ylabel('Accuracy')
plt.legend()

plt.subplot(1, 2, 2)
plt.plot(history.history['loss'], label='Training Loss')
plt.plot(history.history['val_loss'], label='Validation Loss')
plt.title('Model Loss')
plt.xlabel('Epoch')
plt.ylabel('Loss')
plt.legend()

plt.tight_layout()
plt.show()

Desglose del código:

Importación de bibliotecas:
- Se importa TensorFlow y los módulos necesarios de Keras.
- Se importa matplotlib para fines de visualización.
Carga y preprocesamiento de datos:
- El conjunto de datos MNIST se carga utilizando mnist.load_data().
- Los datos de entrada (imágenes) se normalizan dividiéndolos por 255, escalando los valores de píxeles al rango [0, 1].
Construcción del modelo:
- Utilizamos la API Secuencial para crear una pila lineal de capas.
- La arquitectura del modelo incluye:
  - Capa Flatten: Convierte imágenes de 28x28 en vectores 1D de 784 elementos.
  - Capa Densa (128 neuronas): Primera capa oculta con activación ReLU.
  - Capa Dropout (tasa del 20%): Para regularización, ayuda a prevenir el sobreajuste.
  - Capa Densa (64 neuronas): Segunda capa oculta con activación ReLU.
  - Otra capa Dropout (tasa del 20%): Mayor regularización.
  - Capa Densa (10 neuronas): Capa de salida con activación softmax para clasificación de 10 clases.
Compilación del modelo:
- Optimizador: Adam con una tasa de aprendizaje de 0.001.
- Función de pérdida: Entropía cruzada categórica escasa (adecuada para etiquetas enteras).
- Métrica: Precisión (para monitorear durante el entrenamiento y evaluación).
Definición de parada anticipada:
- Se utiliza el callback EarlyStopping para prevenir el sobreajuste.
- Monitorea la pérdida de validación y detiene el entrenamiento si no mejora durante 3 épocas consecutivas.
- restore_best_weights=True asegura que se guarde el mejor modelo.
Entrenamiento del modelo:
- El modelo se entrena utilizando model.fit() con los siguientes parámetros:
  - 20 épocas (pasadas completas sobre los datos de entrenamiento).
  - Tamaño de lote de 32 (número de muestras procesadas antes de actualizar el modelo).
  - Se proporciona un conjunto de datos de validación para monitorear.
  - Se incluye el callback de parada anticipada.
Evaluación del modelo:
- El modelo entrenado se evalúa en el conjunto de prueba usando model.evaluate().
- Se imprime la precisión del conjunto de prueba para evaluar el rendimiento del modelo en datos no vistos.
Visualización del historial de entrenamiento:
- Se crean dos gráficos para visualizar el proceso de entrenamiento:
  - Precisión del modelo: Muestra la precisión de entrenamiento y validación a lo largo de las épocas.
  - Pérdida del modelo: Muestra la pérdida de entrenamiento y validación a lo largo de las épocas.
- Estos gráficos ayudan a entender el progreso del aprendizaje del modelo e identificar posibles sobreajustes o subajustes.

2.2.4 Evaluación del modelo

Después de entrenar, puedes evaluar el modelo en un conjunto de datos de prueba para evaluar su capacidad de generalizar a datos nuevos y no vistos. Este paso crucial ayuda a determinar qué tan bien el modelo se desempeña en datos que no ha encontrado durante el entrenamiento, proporcionando información sobre su aplicabilidad en el mundo real. TensorFlow simplifica este proceso con el método evaluate(), que calcula la pérdida y las métricas del modelo en un conjunto de datos determinado.

El método evaluate() generalmente toma dos argumentos principales: los datos de entrada (X_test) y las etiquetas correspondientes (y_test). Luego ejecuta el paso hacia adelante del modelo en estos datos, calcula la pérdida y las métricas especificadas, y devuelve estos valores. Esto te permite evaluar rápidamente el rendimiento del modelo en el conjunto de prueba.

Por ejemplo, si has especificado la 'precisión' como una métrica durante la compilación del modelo, el método evaluate() devolverá tanto el valor de la pérdida como la puntuación de precisión. Esta información es invaluable para comprender qué tan bien se generaliza tu modelo y puede ayudarte a tomar decisiones sobre un ajuste fino adicional o si el modelo está listo para su implementación.

Es importante tener en cuenta que la evaluación debe realizarse en un conjunto de prueba separado que el modelo no haya visto durante el entrenamiento. Esto asegura una evaluación imparcial del rendimiento del modelo y ayuda a detectar problemas como el sobreajuste, donde el modelo funciona bien en los datos de entrenamiento pero mal en datos nuevos y no vistos.

Ejemplo: Evaluación del modelo

# Evaluate the model on test data
test_loss, test_accuracy = model.evaluate(X_test, y_test, verbose=1)
print(f"Test Loss: {test_loss:.4f}")
print(f"Test Accuracy: {test_accuracy:.4f}")

# Make predictions on test data
y_pred = model.predict(X_test)
y_pred_classes = np.argmax(y_pred, axis=1)

# Generate a classification report
from sklearn.metrics import classification_report
print("\nClassification Report:")
print(classification_report(y_test, y_pred_classes))

# Confusion Matrix
from sklearn.metrics import confusion_matrix
import seaborn as sns

cm = confusion_matrix(y_test, y_pred_classes)
plt.figure(figsize=(10, 8))
sns.heatmap(cm, annot=True, fmt='d', cmap='Blues')
plt.title('Confusion Matrix')
plt.ylabel('True Label')
plt.xlabel('Predicted Label')
plt.show()

# Visualize some predictions
n_to_show = 10
indices = np.random.choice(range(len(X_test)), n_to_show)
fig = plt.figure(figsize=(15, 3))
fig.suptitle("Model Predictions (Actual / Predicted)")

for i, idx in enumerate(indices):
    plt.subplot(1, n_to_show, i+1)
    plt.imshow(X_test[idx].reshape(28, 28), cmap='gray')
    plt.axis('off')
    plt.title(f"{y_test[idx]} / {y_pred_classes[idx]}")

plt.tight_layout()
plt.show()

Desglose del código:

Evaluación del modelo:
- Usamos model.evaluate() para calcular la pérdida y la precisión en el conjunto de prueba.
- El parámetro verbose=1 muestra una barra de progreso durante la evaluación.
- Imprimimos tanto la pérdida como la precisión del conjunto de prueba con 4 decimales para mayor precisión.
Realización de predicciones:
- model.predict() se usa para generar predicciones para todas las muestras de prueba.
- np.argmax() convierte las distribuciones de probabilidad en etiquetas de clase.
Informe de clasificación:
- Importamos classification_report de sklearn.metrics.
- Esto proporciona un desglose detallado de precisión, recall y F1-score para cada clase.
Matriz de confusión:
- Importamos confusion_matrix de sklearn.metrics y seaborn para la visualización.
- La matriz de confusión muestra el conteo de predicciones correctas e incorrectas para cada clase.
- Usamos un heatmap para visualizar la matriz de confusión, con anotaciones que muestran los conteos exactos.
Visualización de predicciones:
- Seleccionamos aleatoriamente 10 muestras del conjunto de prueba para visualizarlas.
- Para cada muestra, mostramos la imagen junto con su etiqueta real y la predicción del modelo.
- Esto ayuda a comprender dónde el modelo realiza predicciones correctas y dónde falla.

Esta evaluación completa proporciona una visión profunda del rendimiento del modelo, yendo más allá de la precisión. Ayuda a identificar áreas específicas donde el modelo sobresale o tiene dificultades, lo cual es crucial para mejorar aún más y comprender el comportamiento del modelo.

2.2.5 Ajuste fino del modelo

El ajuste fino de una red neuronal es una fase crítica en el flujo de trabajo de aprendizaje automático, que implica realizar ajustes meticulosos a varios componentes del modelo para mejorar su rendimiento general. Este proceso, que suele seguir a la fase de entrenamiento inicial, tiene como objetivo optimizar la precisión del modelo, su eficiencia computacional y su capacidad de generalizar a datos no vistos.

Al ajustar cuidadosamente los hiperparámetros, modificar la arquitectura de la red e implementar técnicas avanzadas de regularización, los científicos de datos e ingenieros de aprendizaje automático pueden mejorar significativamente las capacidades del modelo y garantizar que funcione de manera óptima en tareas del mundo real.

Aquí hay varias técnicas comunes empleadas en el proceso de ajuste fino:

Ajuste de la tasa de aprendizaje

La tasa de aprendizaje es un hiperparámetro crítico que gobierna la magnitud de las actualizaciones aplicadas a los pesos del modelo durante el entrenamiento. Desempeña un papel fundamental en la determinación de qué tan rápido o lento el modelo aprende de los datos. Encontrar la tasa de aprendizaje óptima a menudo es un acto de equilibrio delicado:

Tasa de aprendizaje alta: Si se configura demasiado alta, el modelo puede converger demasiado rápido, lo que podría hacer que se pase del punto óptimo. Esto puede llevar a un entrenamiento inestable o incluso causar que el modelo diverja.
Tasa de aprendizaje baja: Por el contrario, si la tasa de aprendizaje es demasiado baja, el entrenamiento puede progresar muy lentamente. Aunque esto puede conducir a actualizaciones más estables, podría requerir un tiempo excesivamente largo para que el modelo converja a una solución óptima.
Tasas de aprendizaje adaptativas: Muchos optimizadores modernos, como Adam o RMSprop, ajustan automáticamente la tasa de aprendizaje durante el entrenamiento, lo que puede ayudar a mitigar algunos de estos problemas.

El ajuste fino de la tasa de aprendizaje a menudo implica técnicas como el uso de programación de tasas de aprendizaje (disminuyendo gradualmente la tasa de aprendizaje con el tiempo) o el uso de tasas de aprendizaje cíclicas para explorar diferentes regiones del espacio de pérdida de manera más efectiva.

Puedes ajustar la tasa de aprendizaje directamente en el optimizador:

# Adjust the learning rate and other parameters of Adam optimizer
model.compile(
    optimizer=tf.keras.optimizers.Adam(
        learning_rate=0.001,  # Lower learning rate
        beta_1=0.9,           # Exponential decay rate for the first moment estimates
        beta_2=0.999,         # Exponential decay rate for the second moment estimates
        epsilon=1e-07,        # Small constant for numerical stability
        amsgrad=False         # Whether to apply AMSGrad variant of Adam
    ),
    loss='sparse_categorical_crossentropy',
    metrics=['accuracy', 'precision', 'recall']
)

# Define learning rate scheduler
def lr_schedule(epoch):
    return 0.001 * (0.1 ** int(epoch / 10))

lr_scheduler = tf.keras.callbacks.LearningRateScheduler(lr_schedule)

# Train the model with the new configuration
history = model.fit(
    X_train, y_train,
    epochs=30,
    batch_size=64,
    validation_split=0.2,
    callbacks=[lr_scheduler]
)

Desglose del código:

Configuración del optimizador:
- Utilizamos el optimizador Adam, que es un algoritmo de optimización de tasa de aprendizaje adaptativa.
- learning_rate=0.001: Una tasa de aprendizaje más baja para un entrenamiento más estable.
- beta_1 y beta_2: Controlan las tasas de decaimiento de los promedios móviles para el gradiente y su cuadrado.
- epsilon: Una constante pequeña para prevenir la división por cero.
- amsgrad: Cuando es True, utiliza la variante AMSGrad de Adam del artículo "On the Convergence of Adam and Beyond".
Pérdida y métricas:
- loss='sparse_categorical_crossentropy': Adecuada para clasificación multiclase con etiquetas enteras.
- metrics: Ahora rastreamos precisión, precisión (precision) y recall para una evaluación más completa.
Programador de tasa de aprendizaje:
- Definimos un programador de tasa de aprendizaje personalizado que reduce la tasa de aprendizaje en un factor de 10 cada 10 épocas.
- Esto puede ayudar a ajustar el modelo a medida que avanza el entrenamiento, permitiendo actualizaciones más grandes al principio y actualizaciones más pequeñas y precisas después.
Entrenamiento del modelo:
- epochs=30: Aumentado desde las típicas 10 para permitir más tiempo de entrenamiento.
- batch_size=64: Tamaño de lote más grande para un entrenamiento potencialmente más rápido en hardware adecuado.
- validation_split=0.2: El 20% de los datos de entrenamiento se utiliza para validación.
- callbacks=[lr_scheduler]: El programador de tasa de aprendizaje se aplica durante el entrenamiento.

Este ejemplo demuestra un enfoque integral para la compilación y el entrenamiento del modelo, incorporando tasas de aprendizaje adaptativas y métricas de rendimiento adicionales. El programador de tasa de aprendizaje permite un proceso de entrenamiento más matizado, lo que puede llevar a un mejor rendimiento del modelo.

Detención temprana (Early Stopping)

La detención temprana es una técnica de regularización poderosa en el aprendizaje automático que ayuda a prevenir el sobreajuste al monitorear el rendimiento del modelo en un conjunto de validación durante el entrenamiento. Este método funciona al hacer un seguimiento de una métrica de rendimiento específica, típicamente la pérdida o la precisión de validación, y detiene el proceso de entrenamiento si esta métrica no mejora durante un número predeterminado de épocas, conocido como el período de "paciencia".

Los principales beneficios de la detención temprana incluyen:

Mejora de la generalización: Al detener el entrenamiento antes de que el modelo comience a sobreajustarse a los datos de entrenamiento, la detención temprana ayuda a que el modelo generalice mejor en datos no vistos.
Eficiencia de tiempo y recursos: Previene el cálculo innecesario al detener el entrenamiento una vez que el rendimiento del modelo se estabiliza o comienza a degradarse.
Selección automática del modelo: La detención temprana selecciona efectivamente el modelo que mejor se desempeña en el conjunto de validación, lo que a menudo es un buen indicador del rendimiento en datos no vistos.

La implementación de la detención temprana generalmente implica configurar un callback en el ciclo de entrenamiento que verifica el rendimiento de validación después de cada época. Si el rendimiento no mejora durante el número de épocas especificado (paciencia), el entrenamiento se termina y los pesos del modelo de la mejor época se restauran.

Si bien la detención temprana es una herramienta valiosa, es importante elegir un valor de paciencia adecuado. Si es demasiado bajo, corres el riesgo de detener el entrenamiento prematuramente; si es demasiado alto, puede que no aproveches los beneficios completos de la detención temprana. El valor óptimo de paciencia a menudo depende del problema específico y del conjunto de datos.

Ejemplo: Implementación de detención temprana

import tensorflow as tf
from tensorflow.keras.callbacks import EarlyStopping, ReduceLROnPlateau
from tensorflow.keras.models import Sequential
from tensorflow.keras.layers import Dense, Dropout
from sklearn.model_selection import train_test_split
from sklearn.preprocessing import StandardScaler
import numpy as np
import matplotlib.pyplot as plt

# Load and preprocess data (assuming X and y are already defined)
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2, random_state=42)

# Normalize the data
scaler = StandardScaler()
X_train_scaled = scaler.fit_transform(X_train)
X_test_scaled = scaler.transform(X_test)

# Define the model
model = Sequential([
    Dense(128, activation='relu', input_shape=(X_train.shape[1],)),
    Dropout(0.3),
    Dense(64, activation='relu'),
    Dropout(0.3),
    Dense(32, activation='relu'),
    Dense(1, activation='sigmoid')
])

# Compile the model
model.compile(optimizer='adam', loss='binary_crossentropy', metrics=['accuracy'])

# Define callbacks
early_stopping = EarlyStopping(
    monitor='val_loss',
    patience=10,
    restore_best_weights=True,
    verbose=1
)

reduce_lr = ReduceLROnPlateau(
    monitor='val_loss',
    factor=0.2,
    patience=5,
    min_lr=1e-6,
    verbose=1
)

# Train the model with early stopping and learning rate reduction
history = model.fit(
    X_train_scaled, y_train,
    epochs=100,
    batch_size=32,
    validation_split=0.2,
    callbacks=[early_stopping, reduce_lr],
    verbose=1
)

# Evaluate the model
test_loss, test_accuracy = model.evaluate(X_test_scaled, y_test, verbose=0)
print(f"Test accuracy: {test_accuracy:.4f}")

# Plot training history
plt.figure(figsize=(12, 4))
plt.subplot(1, 2, 1)
plt.plot(history.history['loss'], label='Training Loss')
plt.plot(history.history['val_loss'], label='Validation Loss')
plt.title('Model Loss')
plt.xlabel('Epoch')
plt.ylabel('Loss')
plt.legend()

plt.subplot(1, 2, 2)
plt.plot(history.history['accuracy'], label='Training Accuracy')
plt.plot(history.history['val_accuracy'], label='Validation Accuracy')
plt.title('Model Accuracy')
plt.xlabel('Epoch')
plt.ylabel('Accuracy')
plt.legend()

plt.tight_layout()
plt.show()

Desglose del código:

Preparación de datos:
- Usamos train_test_split para dividir nuestros datos en conjuntos de entrenamiento y prueba.
- Se aplica StandardScaler para normalizar las características de entrada, lo que puede ayudar a mejorar el rendimiento del modelo y la estabilidad del entrenamiento.
Arquitectura del modelo:
- Se define un modelo Sequential con tres capas Dense y dos capas Dropout.
- Se agregan capas Dropout (con una tasa de 0.3) para regularización y prevenir el sobreajuste.
- La capa final usa una activación sigmoid para clasificación binaria.
Compilación del modelo:
- El modelo se compila usando el optimizador Adam y la pérdida binary_crossentropy, adecuada para tareas de clasificación binaria.
Callbacks:
- EarlyStopping: Monitorea el val_loss con una paciencia de 10 épocas. Si la pérdida de validación no mejora en 10 épocas consecutivas, el entrenamiento se detendrá.
- ReduceLROnPlateau: Reduce la tasa de aprendizaje en un factor de 0.2 si la pérdida de validación no mejora en 5 épocas, lo que permite ajustes finos a medida que avanza el entrenamiento.
Entrenamiento del modelo:
- El modelo se entrena durante un máximo de 100 épocas con un tamaño de lote de 32.
- El 20% de los datos de entrenamiento se utiliza como conjunto de validación.
- Ambos callbacks (detención temprana y reducción de la tasa de aprendizaje) se aplican durante el entrenamiento.
Evaluación del modelo:
- El modelo entrenado se evalúa en el conjunto de prueba para obtener una estimación imparcial de su rendimiento.
Visualización:
- Se grafican la pérdida y la precisión de entrenamiento y validación a lo largo de las épocas para visualizar el progreso del aprendizaje del modelo.
- Estas gráficas pueden ayudar a identificar sobreajuste (si las métricas de entrenamiento y validación divergen) u otros problemas durante el entrenamiento.

Este ejemplo completo demuestra un flujo de trabajo para entrenar una red neuronal, que incluye el preprocesamiento de datos, la definición del modelo, el entrenamiento con técnicas avanzadas como la detención temprana y la reducción de la tasa de aprendizaje, la evaluación y la visualización del progreso del entrenamiento. Proporciona una base sólida para abordar diversas tareas de aprendizaje automático y puede adaptarse fácilmente a diferentes conjuntos de datos y tipos de problemas.

Dropout para regularización

Dropout es una técnica de regularización poderosa en redes neuronales, donde se ignoran temporalmente neuronas seleccionadas al azar o se "desactivan" durante el entrenamiento. Este proceso puede compararse con entrenar un conjunto de múltiples redes neuronales, cada una con una arquitectura ligeramente diferente. Aquí tienes una explicación más detallada de cómo funciona el dropout y por qué es efectivo:

Desactivación aleatoria: Durante cada iteración de entrenamiento, un cierto porcentaje de neuronas (típicamente entre el 20% y el 50%) se seleccionan al azar y sus salidas se configuran en cero. Este porcentaje es un hiperparámetro llamado "tasa de dropout".
Prevención de la co-adaptación: Al desactivar aleatoriamente neuronas, la red se ve obligada a aprender características más robustas que sean útiles en combinación con muchos subconjuntos aleatorios de otras neuronas. Esto previene que las neuronas se adapten demasiado, donde solo funcionan bien en el contexto de otras neuronas específicas.
Reducción del sobreajuste: Dropout reduce efectivamente la capacidad de la red durante el entrenamiento, haciendo menos probable que memorice los datos de entrenamiento. Esto ayuda a reducir el sobreajuste, especialmente en casos donde los datos de entrenamiento son limitados.
Efecto de conjunto: En el momento de la prueba, se usan todas las neuronas, pero sus salidas se escalan hacia abajo por la tasa de dropout. Esto se puede ver como una aproximación de promediar las predicciones de muchas redes diferentes, similar a los métodos de conjuntos.
Mejora de la generalización: Al evitar que el modelo dependa demasiado de cualquier característica o neurona específica, dropout ayuda a que la red generalice mejor a datos no vistos.
Variabilidad en el entrenamiento: Dropout introduce aleatoriedad en el proceso de entrenamiento, lo que puede ayudar al modelo a explorar diferentes combinaciones de características y potencialmente encontrar mejores óptimos locales.

Aunque el dropout es muy efectivo, es importante señalar que puede aumentar el tiempo de entrenamiento, ya que el modelo necesita aprender con diferentes subconjuntos de neuronas. La tasa de dropout óptima suele depender del problema específico y la arquitectura del modelo, y generalmente se trata como un hiperparámetro que se ajusta.

Ejemplo: Agregar capas Dropout

import tensorflow as tf
from tensorflow.keras.models import Sequential
from tensorflow.keras.layers import Dense, Dropout, Flatten
from tensorflow.keras.datasets import mnist
from tensorflow.keras.callbacks import EarlyStopping, ReduceLROnPlateau
import matplotlib.pyplot as plt

# Load and preprocess the MNIST dataset
(X_train, y_train), (X_test, y_test) = mnist.load_data()
X_train, X_test = X_train / 255.0, X_test / 255.0  # Normalize pixel values to [0, 1]

# Build a model with dropout regularization
def create_model(dropout_rate=0.5):
    model = Sequential([
        Flatten(input_shape=(28, 28)),
        Dense(128, activation='relu'),
        Dropout(dropout_rate),
        Dense(64, activation='relu'),
        Dropout(dropout_rate),
        Dense(10, activation='softmax')
    ])
    return model

# Create and compile the model
model = create_model()
model.compile(optimizer='adam',
              loss='sparse_categorical_crossentropy',
              metrics=['accuracy'])

# Define callbacks
early_stopping = EarlyStopping(monitor='val_loss', patience=5, restore_best_weights=True)
reduce_lr = ReduceLROnPlateau(monitor='val_loss', factor=0.2, patience=3, min_lr=1e-5)

# Train the model
history = model.fit(X_train, y_train,
                    epochs=20,
                    batch_size=32,
                    validation_split=0.2,
                    callbacks=[early_stopping, reduce_lr])

# Evaluate the model
test_loss, test_acc = model.evaluate(X_test, y_test, verbose=2)
print(f'\nTest accuracy: {test_acc:.4f}')

# Plot training history
plt.figure(figsize=(12, 4))
plt.subplot(1, 2, 1)
plt.plot(history.history['accuracy'], label='Training Accuracy')
plt.plot(history.history['val_accuracy'], label='Validation Accuracy')
plt.title('Model Accuracy')
plt.xlabel('Epoch')
plt.ylabel('Accuracy')
plt.legend()

plt.subplot(1, 2, 2)
plt.plot(history.history['loss'], label='Training Loss')
plt.plot(history.history['val_loss'], label='Validation Loss')
plt.title('Model Loss')
plt.xlabel('Epoch')
plt.ylabel('Loss')
plt.legend()

plt.tight_layout()
plt.show()

Desglose del código:

Preparación de datos:
- Utilizamos el conjunto de datos MNIST, que está disponible en Keras.
- Los valores de los píxeles se normalizan al rango [0, 1] dividiéndolos por 255.
Arquitectura del modelo:
- Se define un modelo Sequential con tres capas Dense y dos capas Dropout.
- La capa de entrada (Flatten) remodela las imágenes de 28x28 en un arreglo unidimensional.
- Dos capas ocultas con 128 y 64 unidades respectivamente, ambas utilizando activación ReLU.
- Capas Dropout con una tasa de 0.5 se añaden después de cada capa oculta para regularización.
- La capa de salida tiene 10 unidades (una por cada dígito) con activación softmax para clasificación multiclase.
Compilación del modelo:
- El modelo utiliza el optimizador Adam y la pérdida sparse categorical crossentropy, que es adecuada para etiquetas enteras en la clasificación multiclase.
- La métrica usada para evaluación es la precisión.
Callbacks:
- EarlyStopping: Monitorea la pérdida de validación y detiene el entrenamiento si no mejora durante 5 épocas, previniendo el sobreajuste.
- ReduceLROnPlateau: Reduce la tasa de aprendizaje en un factor de 0.2 si la pérdida de validación no mejora en 3 épocas, permitiendo ajustes finos.
Entrenamiento del modelo:
- El modelo se entrena por un máximo de 20 épocas con un tamaño de lote de 32.
- El 20% de los datos de entrenamiento se utiliza como conjunto de validación.
- Ambos callbacks (detención temprana y reducción de la tasa de aprendizaje) se aplican durante el entrenamiento.
Evaluación del modelo:
- El modelo entrenado se evalúa en el conjunto de prueba para obtener una estimación imparcial de su rendimiento.
Visualización:
- Se grafican la precisión y la pérdida de entrenamiento y validación a lo largo de las épocas para visualizar el progreso del aprendizaje del modelo.
- Estas gráficas pueden ayudar a identificar sobreajuste (si las métricas de entrenamiento y validación divergen) u otros problemas de entrenamiento.

Este ejemplo demuestra un enfoque integral para construir y entrenar una red neuronal con regularización por dropout. Cubre el preprocesamiento de datos, la creación del modelo incorporando capas dropout, la compilación y el entrenamiento con técnicas avanzadas como la detención temprana y la reducción de la tasa de aprendizaje.

El proceso también incluye la evaluación del modelo y la visualización del progreso del entrenamiento. Esta configuración robusta mejora el proceso de entrenamiento y proporciona una mayor comprensión y optimización del comportamiento de la red neuronal.

Ajuste de Hiperparámetros con KerasTuner

KerasTuner es una biblioteca poderosa y flexible para optimizar hiperparámetros en modelos de TensorFlow. Proporciona un enfoque sistemático para buscar la combinación óptima de hiperparámetros, como el número de neuronas en cada capa, la tasa de aprendizaje, funciones de activación y otras decisiones de arquitectura del modelo. Al automatizar este proceso, KerasTuner mejora significativamente el rendimiento del modelo y reduce el tiempo y esfuerzo requeridos para el ajuste manual.

Las características clave de KerasTuner incluyen capacidades potentes que mejoran significativamente el proceso de optimización de hiperparámetros:

Algoritmos de búsqueda eficientes: KerasTuner proporciona una amplia gama de estrategias de búsqueda, incluyendo búsqueda aleatoria, optimización bayesiana y Hyperband. Estos algoritmos sofisticados permiten a los investigadores y profesionales explorar de manera eficiente el vasto espacio de hiperparámetros, lo que lleva a configuraciones de modelos más óptimas.
Flexibilidad e integración fluida: Una de las características destacadas de KerasTuner es su capacidad para integrarse sin problemas con los flujos de trabajo existentes de TensorFlow y Keras. Esta flexibilidad le permite adaptarse a una amplia gama de proyectos de aprendizaje profundo, desde modelos simples hasta arquitecturas complejas, convirtiéndolo en una herramienta invaluable tanto para principiantes como para profesionales experimentados.
Escalabilidad para la optimización a gran escala: KerasTuner está diseñado pensando en la escalabilidad, admitiendo capacidades de ajuste distribuido. Esta característica es particularmente crucial para abordar problemas a gran escala, ya que permite una optimización de hiperparámetros más rápida y eficiente en múltiples recursos computacionales, reduciendo significativamente el tiempo necesario para encontrar configuraciones óptimas.
Personalización para satisfacer necesidades específicas: Reconociendo que cada proyecto de aprendizaje automático tiene requisitos únicos, KerasTuner ofrece amplias opciones de personalización. Los usuarios tienen la libertad de definir espacios de búsqueda personalizados y objetivos, lo que les permite adaptar el proceso de ajuste a sus necesidades específicas. Este nivel de personalización asegura que la optimización de hiperparámetros se alinee perfectamente con las particularidades de cada proyecto individual.

Al aprovechar KerasTuner, los científicos de datos y los ingenieros de aprendizaje automático pueden navegar de manera más efectiva por el complejo panorama de la optimización de hiperparámetros, lo que lleva a modelos con mejor precisión, generalización y rendimiento general.

Ejemplo: Ajuste de Hiperparámetros con KerasTuner

pip install keras-tuner

import tensorflow as tf
from tensorflow import keras
from tensorflow.keras import layers
import keras_tuner as kt
import numpy as np
import matplotlib.pyplot as plt

# Load and preprocess the MNIST dataset
(X_train, y_train), (X_test, y_test) = keras.datasets.mnist.load_data()
X_train = X_train.astype("float32") / 255
X_test = X_test.astype("float32") / 255

# Define a function to build the model with tunable hyperparameters
def build_model(hp):
    model = keras.Sequential()
    model.add(layers.Flatten(input_shape=(28, 28)))
    
    # Tune the number of hidden layers
    for i in range(hp.Int("num_layers", 1, 3)):
        # Tune the number of units in each Dense layer
        hp_units = hp.Int(f"units_{i}", min_value=32, max_value=512, step=32)
        model.add(layers.Dense(units=hp_units, activation="relu"))
        
        # Tune dropout rate
        hp_dropout = hp.Float(f"dropout_{i}", min_value=0.0, max_value=0.5, step=0.1)
        model.add(layers.Dropout(hp_dropout))
    
    model.add(layers.Dense(10, activation="softmax"))
    
    # Tune the learning rate
    hp_learning_rate = hp.Float("learning_rate", min_value=1e-4, max_value=1e-2, sampling="LOG")
    
    # Compile the model
    model.compile(
        optimizer=keras.optimizers.Adam(learning_rate=hp_learning_rate),
        loss="sparse_categorical_crossentropy",
        metrics=["accuracy"],
    )
    return model

# Instantiate the tuner
tuner = kt.RandomSearch(
    build_model,
    objective="val_accuracy",
    max_trials=10,
    executions_per_trial=3,
    directory="my_dir",
    project_name="mnist_tuning"
)

# Define early stopping callback
early_stop = keras.callbacks.EarlyStopping(monitor="val_loss", patience=5)

# Perform the search
tuner.search(
    X_train, 
    y_train,
    epochs=50,
    validation_split=0.2,
    callbacks=[early_stop]
)

# Get the best model
best_model = tuner.get_best_models(num_models=1)[0]

# Evaluate the best model
test_loss, test_accuracy = best_model.evaluate(X_test, y_test, verbose=0)
print(f"Test accuracy: {test_accuracy:.4f}")

# Get the best hyperparameters
best_hps = tuner.get_best_hyperparameters(num_trials=1)[0]

# Print the best hyperparameters
print("Best hyperparameters:")
for param, value in best_hps.values.items():
    print(f"{param}: {value}")

# Plot learning curves
history = best_model.fit(
    X_train, 
    y_train,
    epochs=50,
    validation_split=0.2,
    callbacks=[early_stop],
    verbose=0
)

plt.figure(figsize=(12, 4))
plt.subplot(1, 2, 1)
plt.plot(history.history["accuracy"], label="Training Accuracy")
plt.plot(history.history["val_accuracy"], label="Validation Accuracy")
plt.title("Model Accuracy")
plt.xlabel("Epoch")
plt.ylabel("Accuracy")
plt.legend()

plt.subplot(1, 2, 2)
plt.plot(history.history["loss"], label="Training Loss")
plt.plot(history.history["val_loss"], label="Validation Loss")
plt.title("Model Loss")
plt.xlabel("Epoch")
plt.ylabel("Loss")
plt.legend()

plt.tight_layout()
plt.show()

Desglose del código:

Importaciones y preparación de datos:
- Importamos las bibliotecas necesarias, incluyendo TensorFlow, Keras, KerasTuner, NumPy y Matplotlib.
- El conjunto de datos MNIST se carga y se preprocesa. Los valores de los píxeles se normalizan al rango [0, 1].
Función de creación del modelo:
- La función build_model define un modelo con hiperparámetros ajustables.
- Permite un número variable de capas ocultas (de 1 a 3).
- Para cada capa, se ajusta el número de unidades y la tasa de dropout.
- También se ajusta la tasa de aprendizaje para el optimizador Adam.
Ajuste de hiperparámetros:
- Usamos RandomSearch de KerasTuner para buscar los mejores hiperparámetros.
- La búsqueda se establece para ejecutarse en 10 pruebas, con 3 ejecuciones por prueba para mayor robustez.
- Se usa un callback de EarlyStopping para prevenir el sobreajuste durante la búsqueda.
Evaluación del modelo:
- Después de la búsqueda, recuperamos el mejor modelo y lo evaluamos en el conjunto de prueba.
- Se imprimen los mejores hiperparámetros para referencia.
Visualización:
- Volvemos a entrenar el mejor modelo para trazar las curvas de aprendizaje.
- Se visualizan la precisión y la pérdida de entrenamiento y validación a lo largo de las épocas.