Tutorial TensorFlow: Técnicas de validación

¿En qué consiste la validación de modelos?

La validación de modelos es un paso clave en el desarrollo de modelos de aprendizaje automático. Su objetivo es asegurar que el modelo pueda generalizar correctamente a datos nuevos, es decir, no solo funcione bien con los datos con los que fue entrenado, sino también con datos que nunca ha visto antes.

Proceso de validación

Este proceso evalúa el rendimiento del modelo usando conjuntos de datos distintos a los de entrenamiento, lo que permite:

• Medir la eficacia del modelo.
• Detectar problemas como el sobreajuste, que ocurre cuando el modelo se ajusta demasiado a los datos de entrenamiento y no generaliza bien a datos nuevos.

Técnicas de validación

Existen varias técnicas de validación que se eligen según el tipo de datos y el problema que se quiere resolver. Algunas de las más comunes son:

• Validación Hold Out: Divide el conjunto de datos en dos partes, una para entrenamiento y otra para prueba.
• Validación cruzada (Cross-validation): Divide el conjunto de datos en varias partes (subconjuntos) y entrena y prueba el modelo en diferentes combinaciones de estas partes.

Métricas de evaluación

Dependiendo del tipo de problema (como clasificación o regresión), se utilizan métricas específicas para medir el rendimiento del modelo:

• Para clasificación: Exactitud, precisión, recall, F1 score.
• Para regresión: Error cuadrático medio (MSE), error absoluto medio (MAE).

Importancia de la validación rigurosa

Es importante que la validación se haga de manera rigurosa para evitar la contaminación de datos. Esto sucede cuando el conjunto de prueba influye en el entrenamiento, lo que puede dar una estimación inflada del rendimiento real del modelo.

Una buena validación también ayuda a determinar si el modelo:

• Está capturando las tendencias reales en los datos.
• O si está simplemente memorizando ejemplos específicos.

En resumen, la validación de modelos no solo mide la eficacia del modelo, sino que también proporciona insights valiosos para su optimización y mejora continua, asegurando que las soluciones desarrolladas sean robustas y aplicables en escenarios reales.

Validación Hold Out de scikit learn aplicada a TensorFlow Keras

La validación Hold Out es una técnica sencilla y efectiva para evaluar el rendimiento de un modelo de aprendizaje automático. Consiste en dividir el conjunto de datos disponible en dos subconjuntos: uno para el entrenamiento del modelo y otro para su evaluación. Esta separación permite medir la capacidad del modelo para generalizar a datos no vistos durante el entrenamiento, proporcionando una estimación objetiva de su desempeño.

En el contexto de TensorFlow Keras, la validación Hold Out se puede implementar utilizando la función train_test_split de la librería scikit-learn. Este método facilita la partición de los datos de manera aleatoria, asegurando que ambas muestras mantengan la distribución original de las clases o variables continuas. A continuación, se presenta un ejemplo detallado de cómo aplicar esta técnica utilizando un conjunto de datos alternativo al de Boston, ya que este último fue retirado debido a problemas éticos. En su lugar, utilizaremos el conjunto de datos California Housing.

A continuación, se presenta un ejemplo detallado de cómo aplicar esta técnica:

import tensorflow as tf
from tensorflow import keras
from sklearn.model_selection import train_test_split
from sklearn.datasets import fetch_california_housing
from sklearn.preprocessing import StandardScaler

# Cargar el conjunto de datos de California Housing
data = fetch_california_housing()
X, y = data.data, data.target

# Escalado de las características
scaler = StandardScaler()
X_scaled = scaler.fit_transform(X)

# División de los datos en entrenamiento y prueba
X_train, X_test, y_train, y_test = train_test_split(
    X_scaled, y, test_size=0.2, random_state=42
)

# Definición del modelo
model = keras.Sequential([
    keras.layers.Dense(64, activation='relu', input_shape=(X_train.shape[1],)),
    keras.layers.Dense(64, activation='relu'),
    keras.layers.Dense(1)
])

# Compilación del modelo
model.compile(optimizer='adam',
              loss='mse',
              metrics=['mae'])

# Entrenamiento del modelo
history = model.fit(
    X_train, y_train,
    epochs=100,
    batch_size=32,
    validation_data=(X_test, y_test),
    verbose=0
)

# Evaluación del modelo
test_loss, test_mae = model.evaluate(X_test, y_test, verbose=0)
print(f'Error absoluto medio en el conjunto de prueba: {test_mae:.2f}')

En este ejemplo, utilizamos el conjunto de datos California Housing para realizar una tarea de regresión. El proceso sigue los siguientes pasos:

1. Carga y escalado de los datos: El conjunto de datos de California Housing se carga utilizando fetch_california_housing. Luego, las características se escalan con StandardScaler para garantizar que tengan una media de cero y una desviación estándar unitaria, lo que ayuda a mejorar la convergencia del modelo durante el entrenamiento.
2. División de los datos: La función train_test_split divide los datos en un 80% para entrenamiento y un 20% para prueba. Se establece una semilla aleatoria (random_state=42) para garantizar que la división sea reproducible.
3. Definición del modelo: Se define un modelo secuencial con dos capas densas de 64 unidades y una capa de salida con una única unidad, ya que se trata de un problema de regresión.
4. Compilación del modelo: El modelo se compila utilizando el optimizador Adam y la función de pérdida MSE (Error Cuadrático Medio), que es adecuada para problemas de regresión. También se incluye la métrica MAE (Error Absoluto Medio), que es una métrica comúnmente utilizada para este tipo de tareas.
5. Entrenamiento del modelo: El modelo se entrena durante 100 épocas con un tamaño de lote de 32. Se especifica el conjunto de validación (validation_data) para monitorear el rendimiento del modelo en los datos de prueba en cada época.
6. Evaluación del modelo: Después de entrenar el modelo, se evalúa en el conjunto de prueba utilizando model.evaluate(), y se imprime el error absoluto medio en el conjunto de prueba.

En resumen, la técnica Hold Out proporciona una forma eficiente de evaluar el rendimiento de un modelo, especialmente cuando los datos son abundantes. Es una estrategia rápida y fácil de implementar, pero puede complementarse con métodos más precisos en situaciones donde la cantidad de datos es limitada o los resultados son muy sensibles.

Validación cruzada de scikit learn aplicada a TensorFlow Keras

La validación cruzada es una técnica robusta para evaluar la capacidad de generalización de un modelo, especialmente útil cuando se trabaja con conjuntos de datos limitados. A diferencia de la validación Hold Out, que realiza una única división entre entrenamiento y prueba, la validación cruzada divide el conjunto de datos en múltiples subconjuntos o folds, permitiendo que el modelo se entrene y evalúe en diferentes particiones. Esto proporciona una estimación más precisa del rendimiento del modelo y reduce la varianza asociada a una única división de datos.

En el contexto de TensorFlow Keras, la integración con la librería scikit-learn facilita la implementación de la validación cruzada. Para ello, es necesario encapsular el modelo de Keras en un entorno compatible con scikit-learn utilizando clases como KerasClassifier o KerasRegressor, dependiendo del tipo de problema (clasificación o regresión). Esta encapsulación permite utilizar las herramientas de validación cruzada de scikit-learn, como cross_val_score o cross_validate, directamente sobre modelos de Keras.

A continuación, se presenta un ejemplo detallado de cómo aplicar la validación cruzada utilizando cross_val_score de scikit-learn en conjunto con un modelo de TensorFlow Keras:

import tensorflow as tf
from tensorflow import keras
from sklearn.model_selection import cross_val_score, KFold
from sklearn.datasets import load_breast_cancer
from sklearn.preprocessing import StandardScaler
from sklearn.pipeline import Pipeline
from scikeras.wrappers import KerasClassifier
from tensorflow.keras.layers import Input

# Función para crear el modelo Keras
def crear_modelo():
    model = keras.Sequential([
        Input(shape=(30,)),  
        keras.layers.Dense(32, activation='relu'),
        keras.layers.Dense(16, activation='relu'),
        keras.layers.Dense(1, activation='sigmoid')
    ])
    model.compile(optimizer='adam',
                  loss='binary_crossentropy',
                  metrics=['accuracy'])
    return model

# Cargar el conjunto de datos
data = load_breast_cancer()
X, y = data.data, data.target

# Escalado de las características
scaler = StandardScaler()

# Crear el clasificador Keras envuelto para scikit-learn
clf = KerasClassifier(model=crear_modelo, epochs=50, batch_size=16, verbose=0)

# Crear un pipeline que primero escale los datos y luego aplique el clasificador
pipeline = Pipeline([
    ('scaler', scaler),
    ('classifier', clf)
], memory = None)

# Definir la estrategia de validación cruzada
kfold = KFold(n_splits=5, shuffle=True, random_state=42)

# Ejecutar la validación cruzada
resultados = cross_val_score(pipeline, X, y, cv=kfold, scoring='accuracy')

# Mostrar los resultados
print(f'Exactitud media: {resultados.mean():.4f}')
print(f'Desviación estándar: {resultados.std():.4f}')

En este ejemplo, se utiliza el conjunto de datos Breast Cancer para una tarea de clasificación binaria. El proceso comienza con la definición de una función crear_modelo que construye un modelo secuencial de Keras con dos capas ocultas y una capa de salida con activación sigmoide, adecuada para problemas de clasificación binaria. El modelo se compila utilizando el optimizador adam y la función de pérdida binary_crossentropy.

Para integrar el modelo de Keras con scikit-learn, se utiliza KerasClassifier de la librería scikeras, que permite encapsular el modelo de Keras de manera compatible. Posteriormente, se crea un pipeline que incluye una etapa de escalado de características mediante StandardScaler y la aplicación del clasificador.

La estrategia de validación cruzada se define utilizando KFold con 5 folds, asegurando una mezcla aleatoria de los datos mediante shuffle=True y una semilla fija para reproducibilidad. Finalmente, cross_val_score ejecuta la validación cruzada, calculando la exactitud en cada fold y proporcionando la media y desviación estándar de las puntuaciones obtenidas.

Es importante destacar que la validación cruzada no solo proporciona una métrica más fiable del rendimiento del modelo, sino que también ayuda a identificar la consistencia del modelo en diferentes particiones de los datos. Además, al integrar pipelines que incluyen preprocesamiento, se asegura que cada iteración de la validación cruzada realice el escalado de manera independiente, evitando fugas de datos y garantizando la integridad del proceso de validación.

Al aplicar la validación cruzada con TensorFlow Keras y scikit-learn, se aprovechan las capacidades avanzadas de ambas librerías, permitiendo una evaluación exhaustiva y rigurosa del modelo. Este enfoque facilita la optimización de hiperparámetros y la selección de arquitecturas de modelos más adecuadas, contribuyendo al desarrollo de soluciones más robustas y generalizables.

Entrenar el modelo con todos los datos para su futuro despliegue

Una vez completadas las fases de validación y optimización del modelo, es fundamental proceder al entrenamiento final utilizando la totalidad de los datos disponibles. Este paso asegura que el modelo aproveche al máximo la información contenida en el conjunto de datos, incrementando su capacidad de generalización y preparación para el despliegue en entornos de producción.

El entrenamiento con todos los datos implica combinar los subconjuntos de entrenamiento y validación utilizados previamente. Al hacerlo, se elimina la separación que existía para la evaluación, permitiendo que el modelo aprenda de todas las variaciones presentes en el conjunto de datos. Este enfoque es especialmente beneficioso en contextos donde los datos son limitados, ya que maximiza la exposición del modelo a diversas muestras durante el aprendizaje.

A continuación, se presenta un ejemplo práctico actualizado para realizar el entrenamiento final de un modelo en TensorFlow Keras, utilizando todos los datos disponibles, con el conjunto de datos California Housing como sustituto del conjunto de datos Boston Housing, que ha sido retirado debido a problemas éticos.

import tensorflow as tf
from tensorflow import keras
from sklearn.datasets import fetch_california_housing
from sklearn.preprocessing import StandardScaler

# Cargar el conjunto de datos California Housing
data = fetch_california_housing()
X, y = data.data, data.target

# Escalado de las características
scaler = StandardScaler()
X_scaled = scaler.fit_transform(X)

# Definición del modelo
model = keras.Sequential([
    keras.layers.Dense(64, activation='relu', input_shape=(X_scaled.shape[1],)),
    keras.layers.Dense(64, activation='relu'),
    keras.layers.Dense(1)
])

# Compilación del modelo
model.compile(optimizer='adam',
              loss='mse',
              metrics=['mae'])

# Entrenamiento del modelo con todos los datos
history = model.fit(
    X_scaled, y,
    epochs=100,
    batch_size=32,
    verbose=1
)

# Guardado del modelo entrenado para su despliegue
model.save('modelo_final.h5')

En este ejemplo actualizado, se utiliza el conjunto de datos California Housing para realizar una tarea de regresión. A continuación, se detallan los pasos:

1. Carga y escalado de las características: El conjunto de datos California Housing se carga utilizando fetch_california_housing. Posteriormente, se aplica StandardScaler para escalar las características, asegurando que todas tengan una media cero y una desviación estándar unitaria. Esto facilita la convergencia del modelo durante el entrenamiento.
2. Definición del modelo: El modelo se define de manera secuencial, con dos capas densas (de 64 neuronas cada una) y una capa de salida con una única neurona para predecir valores continuos. La función de activación ReLU se utiliza en las capas ocultas, y el modelo final tiene una salida sin activación, ya que estamos trabajando con una tarea de regresión.
3. Compilación del modelo: Se utiliza el optimizador Adam, que es muy popular para tareas de regresión. La función de pérdida es MSE (Error Cuadrático Medio), adecuada para este tipo de problema, y la métrica MAE (Error Absoluto Medio) se incluye para monitorear el rendimiento del modelo durante el entrenamiento.
4. Entrenamiento del modelo: El modelo se entrena utilizando todos los datos disponibles (X_scaled y y), sin separación previa en conjuntos de entrenamiento y validación. Esto permite que el modelo aprenda de toda la información disponible. Se especifican 100 épocas de entrenamiento, con un tamaño de lote de 32 y una visualización del progreso de entrenamiento (verbose=1).
5. Guardado del modelo: Después de entrenar el modelo, se guarda utilizando model.save('modelo_final.h5'). Este archivo contiene tanto la arquitectura del modelo como los pesos entrenados, y puede ser cargado posteriormente para su despliegue en aplicaciones reales.

Es importante destacar que, antes del despliegue, se debe considerar la evaluación adicional del modelo en conjuntos de datos externos o en escenarios del mundo real para confirmar su eficacia y robustez. Además, al desplegar el modelo, es recomendable implementar prácticas de monitorización y mantenimiento continuo para asegurar su rendimiento óptimo a lo largo del tiempo.