Herramientas y optimización

TensorFlow ofrece un ecosistema completo de herramientas que permiten optimizar y supervisar modelos de aprendizaje profundo. En esta sección, exploraremos componentes fundamentales que todo desarrollador de IA debería dominar para construir modelos eficientes y robustos.

TensorBoard es la herramienta de visualización por excelencia de TensorFlow, diseñada para facilitar el entendimiento, depuración y optimización de modelos. Su integración con el framework es nativa y permite monitorizar diversos aspectos del entrenamiento en tiempo real. Para utilizarla, debemos primero configurar callbacks en nuestro modelo:

import tensorflow as tf
from tensorflow.keras.callbacks import TensorBoard
import datetime

# Crear directorio de logs con marca temporal
log_dir = "logs/fit/" + datetime.datetime.now().strftime("%Y%m%d-%H%M%S")

# Crear callback de TensorBoard
tensorboard_callback = TensorBoard(
    log_dir=log_dir,
    histogram_freq=1,  # Frecuencia para visualizar histogramas de pesos
    profile_batch='500,520',  # Perfilar rendimiento en estos lotes
    update_freq='epoch'  # Actualizar métricas cada época
)

# Añadir el callback al entrenamiento
model.fit(
    x_train, y_train,
    epochs=50,
    validation_data=(x_val, y_val),
    callbacks=[tensorboard_callback]
)

Una vez configurado, podemos iniciar TensorBoard en la terminal con el siguiente comando:

tensorboard --logdir=logs/fit

TensorBoard proporciona varias pestañas con información valiosa:

• Scalars: Muestra la evolución de métricas como pérdida y precisión
• Graphs: Visualiza la estructura del modelo como un grafo
• Distributions y Histograms: Muestran la distribución de los pesos del modelo
• Images: Permite visualizar imágenes durante el entrenamiento
• Text: Muestra salidas de texto para modelos de NLP
• Projector: Visualiza embeddings en un espacio tridimensional
• Profiler: Analiza el rendimiento computacional del modelo
• HParams: Facilita la comparación de diferentes hiperparámetros

La pestaña Scalars es particularmente útil para detectar problemas como sobreajuste (cuando la pérdida de entrenamiento sigue disminuyendo pero la de validación empieza a aumentar) o estancamiento en el aprendizaje. Para registrar métricas personalizadas, podemos usar:

# Escritor de logs para TensorBoard
writer = tf.summary.create_file_writer(log_dir)

# Registrar métricas personalizadas
with writer.as_default():
    for epoch in range(num_epochs):
        # Código de entrenamiento...
        
        # Registrar métricas personalizadas
        tf.summary.scalar('learning_rate', current_lr, step=epoch)
        tf.summary.scalar('custom_metric', valor_metrica, step=epoch)
        
        # También podemos registrar imágenes
        tf.summary.image('ejemplos_generados', imagenes_generadas, step=epoch, max_outputs=4)

TensorBoard también permite comparar múltiples experimentos simultáneamente, facilitando la selección del mejor modelo. Para ello, simplemente organizamos nuestros logs en diferentes carpetas:

# Experimento 1: learning rate alto
exp1_dir = "logs/exp1/"
# Experimento 2: learning rate bajo
exp2_dir = "logs/exp2/"

Luego iniciamos TensorBoard apuntando al directorio principal:

tensorboard --logdir=logs/

El Transfer Learning o aprendizaje por transferencia es una técnica poderosa que aprovecha el conocimiento adquirido por un modelo preentrenado y lo aplica a un nuevo problema. En TensorFlow, podemos implementarlo fácilmente mediante la API de Keras:

# Cargar modelo preentrenado
base_model = tf.keras.applications.MobileNetV2(
    input_shape=(224, 224, 3),
    include_top=False,  # No incluir la capa de clasificación final
    weights='imagenet'  # Cargar pesos preentrenados en ImageNet
)

# Congelar el modelo base para mantener sus pesos intactos
base_model.trainable = False

# Crear modelo completo añadiendo capas personalizadas
model = tf.keras.Sequential([
    base_model,
    tf.keras.layers.GlobalAveragePooling2D(),
    tf.keras.layers.Dense(256, activation='relu'),
    tf.keras.layers.Dropout(0.5),
    tf.keras.layers.Dense(num_classes, activation='softmax')
])

# Compilar y entrenar el modelo
model.compile(
    optimizer=tf.keras.optimizers.Adam(learning_rate=0.001),
    loss='categorical_crossentropy',
    metrics=['accuracy']
)

Existen diferentes estrategias para aplicar transfer learning:

1. Feature extraction: Se congela el modelo base y solo se entrenan las capas nuevas.
2. Fine-tuning: Después de entrenar con el modelo base congelado, se descongelan algunas capas (generalmente las más profundas) y se entrena con una tasa de aprendizaje muy baja.

Para implementar fine-tuning después del entrenamiento inicial:

# Descongelar las últimas N capas del modelo base
fine_tune_at = -20  # Últimas 20 capas
for layer in base_model.layers[:fine_tune_at]:
    layer.trainable = False
for layer in base_model.layers[fine_tune_at:]:
    layer.trainable = True

# Recompilar con una tasa de aprendizaje más baja
model.compile(
    optimizer=tf.keras.optimizers.Adam(learning_rate=1e-5),  # Tasa más baja
    loss='categorical_crossentropy',
    metrics=['accuracy']
)

# Continuar el entrenamiento
model.fit(
    train_dataset,
    epochs=additional_epochs,
    validation_data=validation_dataset
)

TensorFlow ofrece numerosos modelos preentrenados a través de tf.keras.applications, incluyendo:

• ResNet: Ideal para tareas generales de visión
• EfficientNet: Ofrece un buen equilibrio entre precisión y eficiencia
• MobileNet: Optimizado para dispositivos móviles
• BERT, GPT y otros a través de TensorFlow Hub: Para tareas de procesamiento de lenguaje natural

El ajuste o tuning de hiperparámetros es esencial para maximizar el rendimiento de nuestros modelos. TensorFlow proporciona varias herramientas para automatizar este proceso, siendo Keras Tuner una de las más populares:

import keras_tuner as kt

# Definir un modelo con hiperparámetros ajustables
def build_model(hp):
    model = tf.keras.Sequential()
    
    # Hiperparámetro: número de unidades en la primera capa densa
    units = hp.Int('units', min_value=32, max_value=512, step=32)
    model.add(tf.keras.layers.Dense(units=units, activation='relu', input_shape=(input_dim,)))
    
    # Hiperparámetro: tasa de dropout
    dropout_rate = hp.Float('dropout', min_value=0.0, max_value=0.5, step=0.1)
    model.add(tf.keras.layers.Dropout(dropout_rate))
    
    # Hiperparámetro: número de capas
    for i in range(hp.Int('num_layers', 1, 4)):
        model.add(tf.keras.layers.Dense(
            units=hp.Int(f'units_{i}', min_value=32, max_value=256, step=32),
            activation='relu'
        ))
    
    model.add(tf.keras.layers.Dense(num_classes, activation='softmax'))
    
    # Hiperparámetro: tasa de aprendizaje
    learning_rate = hp.Float('learning_rate', min_value=1e-4, max_value=1e-2, sampling='log')
    
    model.compile(
        optimizer=tf.keras.optimizers.Adam(learning_rate=learning_rate),
        loss='categorical_crossentropy',
        metrics=['accuracy']
    )
    
    return model

# Configurar el buscador de hiperparámetros
tuner = kt.RandomSearch(
    build_model,
    objective='val_accuracy',  # Métrica a optimizar
    max_trials=50,  # Número máximo de combinaciones a probar
    directory='hp_search',  # Directorio para guardar resultados
    project_name='my_model_tuning'
)

# Iniciar la búsqueda
tuner.search(
    x_train, y_train,
    epochs=20,
    validation_data=(x_val, y_val),
    callbacks=[tf.keras.callbacks.EarlyStopping(patience=5)]
)

# Obtener los mejores hiperparámetros
best_hps = tuner.get_best_hyperparameters(num_trials=1)[0]
print(f"Unidades óptimas: {best_hps.get('units')}")
print(f"Tasa de dropout óptima: {best_hps.get('dropout')}")
print(f"Tasa de aprendizaje óptima: {best_hps.get('learning_rate')}")

# Construir y entrenar el modelo con los mejores hiperparámetros
best_model = tuner.hypermodel.build(best_hps)

Keras Tuner ofrece diferentes algoritmos de búsqueda:

• RandomSearch: Prueba combinaciones aleatorias de hiperparámetros
• BayesianOptimization: Utiliza inferencia bayesiana para seleccionar las próximas combinaciones a probar
• Hyperband: Algoritmo basado en bandit multi-armado que asigna recursos de manera eficiente
• GridSearch: Prueba todas las combinaciones posibles (factible solo para espacios pequeños)

Para búsquedas más sofisticadas, podemos integrar TensorFlow con bibliotecas especializadas como Optuna:

import optuna

def objective(trial):
    # Definir hiperparámetros a optimizar
    learning_rate = trial.suggest_float('learning_rate', 1e-5, 1e-2, log=True)
    units = trial.suggest_categorical('units', [64, 128, 256, 512])
    dropout = trial.suggest_float('dropout', 0.1, 0.5)
    batch_size = trial.suggest_categorical('batch_size', [16, 32, 64, 128])
    
    # Construir modelo
    model = tf.keras.Sequential([
        tf.keras.layers.Dense(units, activation='relu', input_shape=(input_dim,)),
        tf.keras.layers.Dropout(dropout),
        tf.keras.layers.Dense(num_classes, activation='softmax')
    ])
    
    model.compile(
        optimizer=tf.keras.optimizers.Adam(learning_rate=learning_rate),
        loss='categorical_crossentropy',
        metrics=['accuracy']
    )
    
    # Entrenar modelo
    history = model.fit(
        x_train, y_train,
        batch_size=batch_size,
        epochs=20,
        validation_data=(x_val, y_val),
        callbacks=[tf.keras.callbacks.EarlyStopping(patience=5)],
        verbose=0
    )
    
    # Devolver la métrica a optimizar
    return history.history['val_accuracy'][-1]

# Crear estudio y optimizar
study = optuna.create_study(direction='maximize')
study.optimize(objective, n_trials=100)

# Obtener los mejores hiperparámetros
best_trial = study.best_trial
print(f"Mejores hiperparámetros: {best_trial.params}")