TensorFlow, Keras y TensorBoard para monitorizar modelos

TensorFlow, desarrollado por Google Brain y publicado en 2015, no es solo una biblioteca de aprendizaje profundo — es todo un ecosistema para construir, entrenar, desplegar y monitorizar modelos de aprendizaje automático a cualquier escala. Mientras PyTorch domina la investigación, TensorFlow sigue siendo el motor de producción, desplegado en sistemas que procesan miles de millones de predicciones al día en Google, Airbnb, Twitter y miles de otras empresas.

El ecosistema cubre todo el ciclo de vida del ML:

• Keras — La API de alto nivel para construir y entrenar modelos, ahora totalmente integrada en TensorFlow como tf.keras
• TensorBoard — Conjunto de herramientas de visualización para monitorizar el entrenamiento, comparar experimentos y depurar modelos
• tf.data — Pipelines de datos de alto rendimiento para alimentar modelos con grandes conjuntos de datos
• TensorFlow Serving — Servicio de modelos de nivel de producción con versionado, agrupación por lotes (batching) y aceleración hardware
• TensorFlow Lite — Entorno de ejecución optimizado para dispositivos móviles y edge
• TensorFlow.js — Ejecuta modelos directamente en el navegador

Esta amplitud es la mayor fortaleza de TensorFlow. Puedes prototipar un modelo en un notebook de Jupyter con Keras, entrenarlo en un clúster de GPU, monitorizar el entrenamiento con TensorBoard, servirlo con TF Serving detrás de una API y desplegar una versión comprimida en una Raspberry Pi — todo dentro del mismo framework. Para aplicaciones financieras en las que puedes necesitar modelos ejecutándose tanto en un motor de trading en la nube (conectado a la API de GaiaEx) como en una estación de trabajo local para investigación, esta versatilidad importa.

Keras se diseñó con un principio rector: reducir la carga cognitiva de construir redes neuronales. Lo consigue mediante dos API de construcción de modelos, cada una adecuada para un nivel de complejidad distinto.

La API Sequential es la más sencilla — una pila lineal de capas:

import tensorflow as tf
from tensorflow import keras

model = keras.Sequential([
    keras.layers.Dense(128, activation="relu", input_shape=(20,)),
    keras.layers.Dropout(0.3),
    keras.layers.Dense(64, activation="relu"),
    keras.layers.Dropout(0.2),
    keras.layers.Dense(1, activation="sigmoid"),
])

Para modelos con múltiples entradas, múltiples salidas, capas compartidas o conexiones de salto (skip connections), la API Functional te da control total a nivel de grafo:

price_input = keras.Input(shape=(60, 5), name="price_sequence")
meta_input = keras.Input(shape=(10,), name="metadata")

x = keras.layers.LSTM(64, return_sequences=True)(price_input)
x = keras.layers.LSTM(32)(x)

combined = keras.layers.concatenate([x, meta_input])
combined = keras.layers.Dense(64, activation="relu")(combined)
output = keras.layers.Dense(1, activation="sigmoid")(combined)

model = keras.Model(inputs=[price_input, meta_input],
                    outputs=output)

Este modelo toma dos entradas — una secuencia de precios de 60 pasos procesada por LSTM apiladas, y un vector de metadatos con características estáticas — las combina, y produce una predicción direccional. Esta arquitectura es habitual en ML financiero cuando quieres combinar patrones temporales (la acción del precio reciente) con información contextual (régimen de volatilidad, tasa de financiamiento, día de la semana).

Tipos de capa clave para aplicaciones financieras: Dense para características tabulares, LSTM y GRU para series temporales, Conv1D para aprender patrones temporales locales, y MultiHeadAttention para modelado de secuencias al estilo transformer.

Una vez construido, un modelo de Keras debe compilarse con tres componentes: un optimizador, una función de pérdida y métricas de evaluación.

model.compile(
    optimizer=keras.optimizers.Adam(learning_rate=1e-3),
    loss="binary_crossentropy",
    metrics=["accuracy", keras.metrics.AUC(name="auc")],
)

history = model.fit(
    X_train, y_train,
    epochs=100,
    batch_size=64,
    validation_data=(X_val, y_val),
    callbacks=[...],
)

Los callbacks son ganchos (hooks) que se ejecutan en momentos concretos del entrenamiento — después de cada época, de cada batch, o cuando se cumplen ciertas condiciones. Automatizan la gestión del entrenamiento que de otro modo requeriría monitorización manual:

• EarlyStopping — Detiene el entrenamiento cuando la pérdida de validación deja de mejorar durante patience épocas. Evita el sobreajuste y el gasto de cómputo innecesario. Configura restore_best_weights=True para volver automáticamente al mejor checkpoint.
• ModelCheckpoint — Guarda el modelo cada vez que mejora el rendimiento en validación. Nunca pierdes tu mejor modelo por un fallo del entrenamiento o por sobreajuste en épocas posteriores.
• ReduceLROnPlateau — Reduce la tasa de aprendizaje cuando la pérdida de validación se estanca. Esto a menudo desbloquea un rendimiento adicional que una tasa de aprendizaje fija no consigue — el modelo da pasos grandes al principio y luego se ajusta con pasos más pequeños.

callbacks = [
    keras.callbacks.EarlyStopping(
        monitor="val_loss", patience=15,
        restore_best_weights=True),
    keras.callbacks.ModelCheckpoint(
        "best_model.keras", monitor="val_auc",
        mode="max", save_best_only=True),
    keras.callbacks.ReduceLROnPlateau(
        monitor="val_loss", factor=0.5,
        patience=5, min_lr=1e-6),
    keras.callbacks.TensorBoard(log_dir="./logs"),
]

TensorBoard es el conjunto de herramientas de visualización de TensorFlow, y es una de las herramientas más valiosas en el flujo de trabajo de cualquier profesional de ML — ya uses TensorFlow, PyTorch o JAX. Convierte los registros de entrenamiento en bruto en paneles interactivos que revelan lo que ocurre dentro de tu modelo.

Lanza TensorBoard señalando tu directorio de registros:

# Terminal
tensorboard --logdir=./logs --port=6006

# Or in a Jupyter notebook
%load_ext tensorboard
%tensorboard --logdir ./logs

Visualizaciones clave para el desarrollo de modelos financieros:

Scalars — Curvas de pérdida de entrenamiento y validación representadas a lo largo del tiempo. La brecha entre ellas revela el sobreajuste: una pérdida de entrenamiento que sigue bajando mientras la pérdida de validación sube significa que tu modelo está memorizando ruido. Un entrenamiento sano muestra ambas curvas bajando juntas, con la curva de validación ligeramente por encima de la de entrenamiento.

Histograms — Distribuciones de pesos, sesgos (biases) y activaciones a lo largo de las capas y las épocas. Vigila si las distribuciones de pesos colapsan a cero (gradientes que se desvanecen), explotan a valores enormes (entrenamiento inestable), o las activaciones se saturan en 0 o en 1 (neuronas muertas). Estos problemas son invisibles en las curvas de pérdida, pero evidentes en los histogramas.

Embeddings — Proyecta representaciones de alta dimensión en un espacio 2D o 3D usando t-SNE o PCA. Visualiza si tu modelo ha aprendido a separar distintos regímenes de mercado, clases de activos o estados de volatilidad en sus representaciones internas.

HParams — Compara barridos de hiperparámetros entre experimentos. Ejecuta el mismo modelo con distintas tasas de aprendizaje, arquitecturas y valores de dropout, y luego identifica qué combinaciones producen las mejores métricas de validación. Esta comparación sistemática sustituye la experimentación improvisada por una selección de modelos basada en evidencia.

TensorBoard también funciona con PyTorch a través de la clase torch.utils.tensorboard.SummaryWriter — las herramientas de visualización son independientes del framework, lo que es una de las razones por las que TensorBoard se ha convertido en un estándar de facto en todo el ecosistema de ML.

Cuando tu conjunto de datos es demasiado grande para caber en memoria — una situación habitual al trabajar con datos a nivel de tick de exchanges como GaiaEx — tf.data ofrece un pipeline de datos eficiente y paralelizado que mantiene tu GPU alimentada sin cargarlo todo de golpe.

dataset = tf.data.Dataset.from_tensor_slices((features, labels))
dataset = (dataset
    .window(60, shift=1, drop_remainder=True)
    .flat_map(lambda w: w.batch(60))
    .batch(64)
    .prefetch(tf.data.AUTOTUNE)
)

La llamada prefetch(AUTOTUNE) es fundamental — permite que la carga de datos y el cómputo del modelo se solapen, de forma que la GPU nunca se queda inactiva esperando el siguiente batch. Para conjuntos de datos financieros con ingeniería de características compleja, puedes encadenar transformaciones .map() que se ejecutan en paralelo, calculando indicadores y normalizaciones al vuelo en lugar de precalcularlos y almacenarlos.

TensorFlow Serving es un sistema de nivel de producción para desplegar modelos detrás de una API gRPC o REST de alto rendimiento. Gestiona el versionado de modelos (servir el modelo nuevo mientras se mantiene el antiguo como respaldo), la agrupación de solicitudes (request batching, para combinar varias solicitudes de inferencia y ganar eficiencia en la GPU), y la aceleración hardware — todo ello crítico en sistemas de trading donde importan tanto la latencia como la fiabilidad.

# Export a SavedModel
model.save("models/price_predictor/1")

# Serve with Docker
# docker run -p 8501:8501 \
#   --mount type=bind,source=$(pwd)/models,target=/models \
#   -e MODEL_NAME=price_predictor \
#   tensorflow/serving

Una arquitectura de producción típica: tu bot de trading se conecta al feed de WebSocket de GaiaEx, calcula características en tiempo real, envía solicitudes de inferencia a TF Serving y recibe predicciones en milisegundos de un solo dígito. Cuando reentrenas con datos nuevos, despliegas el modelo actualizado como la versión 2 — TF Serving lo sustituye sin tiempo de inactividad.

TensorFlow Lite comprime modelos para desplegarlos en dispositivos móviles, sistemas embebidos y hardware edge. Mediante técnicas como la cuantización (convertir pesos de coma flotante de 32 bits en enteros de 8 bits), el pruning (eliminar pesos casi nulos) y la optimización de la arquitectura, TF Lite puede reducir un modelo 4 veces o más conservando la mayor parte de su precisión. Esto permite ejecutar inferencia directamente en dispositivos con cómputo limitado — útil para nodos de trading en el edge o paneles de monitorización que necesitan operar de forma independiente de la infraestructura en la nube.

# Convert a Keras model to TF Lite
converter = tf.lite.TFLiteConverter.from_saved_model("models/v1")
converter.optimizations = [tf.lite.Optimize.DEFAULT]
tflite_model = converter.convert()

with open("model.tflite", "wb") as f:
    f.write(tflite_model)

TensorFlow frente a PyTorch: ¿cuál elegir para aplicaciones financieras?

• Para investigación y prototipado: PyTorch. Sus grafos dinámicos, su API «pythonica» y su posición dominante en la investigación académica hacen que haya más papers con código en PyTorch, más tutoriales que lo usan, y que la depuración sea más intuitiva.
• Para el despliegue en producción a gran escala: TensorFlow sigue teniendo ventajas. TF Serving, TF Lite y TensorFlow.js ofrecen rutas de despliegue probadas en batalla, hacia las que TorchServe y ONNX Runtime de PyTorch todavía están madurando.
• Para el ML financiero en concreto: empieza con PyTorch para el desarrollo y la experimentación de modelos. Si tus requisitos de producción exigen la madurez de TF Serving o el despliegue en edge de TF Lite, convierte tus mejores modelos. Muchos equipos usan PyTorch para investigación y TensorFlow para el despliegue, uniendo ambos mediante el formato ONNX (Open Neural Network Exchange).

La verdad, sin adornos: ambos frameworks están convergiendo. TensorFlow adoptó la ejecución eager; PyTorch añadió torch.compile para la optimización a nivel de grafo. Keras en sí mismo ahora admite PyTorch, JAX y TensorFlow como backends. El mejor framework es el que tu equipo conoce bien y con el que puede llevar código a producción. Elige uno, domínalo, y resuelve el problema real — predecir los mercados — en lugar de debatir sobre herramientas.