TensorFlow, Keras, e TensorBoard per il monitoraggio dei modelli

TensorFlow, sviluppato da Google Brain e rilasciato nel 2015, non è solo una libreria di deep learning — è un intero ecosistema per costruire, addestrare, distribuire, e monitorare modelli di machine learning a qualsiasi scala. Mentre PyTorch domina la ricerca, TensorFlow resta la potenza della produzione, distribuito in sistemi che processano miliardi di predizioni giornalmente a Google, Airbnb, Twitter, e migliaia di altre aziende.

L'ecosistema copre l'intero ciclo di vita ML:

• Keras — L'API di alto livello per costruire e addestrare modelli, ora completamente integrata in TensorFlow come tf.keras
• TensorBoard — Toolkit di visualizzazione per monitorare l'addestramento, confrontare esperimenti, e fare debug dei modelli
• tf.data — Pipeline dati ad alte prestazioni per alimentare grandi dataset ai modelli
• TensorFlow Serving — Servizio di modelli di livello produzione con versioning, batching, e accelerazione hardware
• TensorFlow Lite — Runtime ottimizzato per dispositivi mobili e edge
• TensorFlow.js — Esegui modelli direttamente nel browser

Questa ampiezza è il più grande punto di forza di TensorFlow. Puoi prototipare un modello in un notebook Jupyter con Keras, addestrarlo su un cluster GPU, monitorare l'addestramento con TensorBoard, servirlo con TF Serving dietro un'API, e distribuire una versione compressa su un Raspberry Pi — tutto all'interno dello stesso framework. Per applicazioni finanziarie dove potresti aver bisogno di modelli in esecuzione sia in un motore di trading su cloud (connesso all'API di GaiaEx) sia su una workstation locale per la ricerca, questa versatilità conta.

Keras è stato progettato con un principio guida: ridurre il carico cognitivo di costruire reti neurali. Lo raggiunge tramite due API di costruzione modelli, ciascuna adatta a livelli di complessità diversi.

L'API Sequential è la più semplice — uno stack lineare di layer:

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"),
])

Per modelli con input multipli, output multipli, layer condivisi, o connessioni skip, l'API Functional ti dà pieno controllo a livello di 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)

Questo modello prende due input — una sequenza di prezzo a 60 step processata da LSTM impilati, e un vettore di metadati di feature statiche — li combina, e produce una predizione direzionale. Questa architettura è comune nel ML finanziario dove vuoi mescolare pattern temporali (azione di prezzo recente) con informazioni contestuali (regime di volatilità, funding rate, giorno della settimana).

Tipi di layer chiave per applicazioni finanziarie: Dense per feature tabulari, LSTM e GRU per serie temporali, Conv1D per apprendere pattern temporali locali, e MultiHeadAttention per il modeling di sequenze in stile transformer.

Una volta costruito, un modello Keras deve essere compilato con tre componenti: un optimizer, una loss function, e metriche di valutazione.

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=[...],
)

I callback sono hook che si eseguono in punti specifici durante l'addestramento — dopo ogni epoca, batch, o quando certe condizioni sono soddisfatte. Automatizzano la gestione dell'addestramento che altrimenti richiederebbe monitoraggio manuale:

• EarlyStopping — Interrompe l'addestramento quando la loss di validazione smette di migliorare per patience epoche. Previene l'overfitting e il compute sprecato. Imposta restore_best_weights=True per tornare automaticamente al miglior checkpoint.
• ModelCheckpoint — Salva il modello ogni volta che la performance di validazione migliora. Non perdere mai il tuo miglior modello a causa di un crash dell'addestramento o overfitting nelle epoche successive.
• ReduceLROnPlateau — Riduce il learning rate quando la loss di validazione si stabilizza. Questo spesso sblocca performance aggiuntiva che un learning rate fisso perde — il modello fa grandi passi inizialmente, poi si affina con passi più piccoli.

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 è il toolkit di visualizzazione di TensorFlow, ed è uno degli strumenti più preziosi nel workflow di qualsiasi praticante ML — che tu usi TensorFlow, PyTorch, o JAX. Trasforma i log di addestramento grezzi in dashboard interattivi che rivelano cosa sta succedendo dentro il tuo modello.

Lancia TensorBoard puntandolo alla tua directory di log:

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

# Oppure in un notebook Jupyter
%load_ext tensorboard
%tensorboard --logdir ./logs

Visualizzazioni chiave per lo sviluppo di modelli finanziari:

Scalars — Curve di loss di addestramento e validazione tracciate nel tempo. Il divario tra loro rivela l'overfitting: una loss di addestramento che continua a diminuire mentre la loss di validazione aumenta significa che il tuo modello sta memorizzando rumore. Un addestramento sano mostra entrambe le curve diminuire insieme, con la curva di validazione leggermente sopra quella di addestramento.

Histograms — Distribuzioni di pesi, bias, e attivazioni attraverso layer ed epoche. Osserva le distribuzioni di pesi che collassano a zero (gradienti che svaniscono), esplodono a valori grandi (addestramento instabile), o attivazioni che saturano a 0 o 1 (neuroni morti). Questi problemi sono invisibili nelle curve di loss ma ovvi negli histogram.

Embeddings — Proietta rappresentazioni ad alta dimensionalità in spazio 2D o 3D usando t-SNE o PCA. Visualizza se il tuo modello ha imparato a separare diversi regimi di mercato, classi di asset, o stati di volatilità nelle sue rappresentazioni interne.

HParams — Confronta sweep di iperparametri attraverso esperimenti. Esegui lo stesso modello con learning rate diversi, architetture diverse, e valori di dropout diversi, poi identifica quali combinazioni producono le migliori metriche di validazione. Questo confronto sistematico sostituisce la sperimentazione ad hoc con la selezione di modelli basata su evidenze.

TensorBoard funziona anche con PyTorch tramite la classe torch.utils.tensorboard.SummaryWriter — gli strumenti di visualizzazione sono agnostici al framework, che è uno dei motivi per cui TensorBoard è diventato uno standard de facto attraverso l'ecosistema ML.

Quando il tuo dataset è troppo grande per stare in memoria — una situazione comune quando lavori con dati a livello di tick da exchange come GaiaEx — tf.data fornisce una pipeline dati efficiente e parallelizzata che mantiene la tua GPU alimentata senza caricare tutto in una volta.

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 chiamata prefetch(AUTOTUNE) è critica — permette al caricamento dei dati e al calcolo del modello di sovrapporsi, così la GPU non resta mai inattiva aspettando il prossimo batch. Per dataset finanziari con feature engineering complessa, puoi concatenare trasformazioni .map() che si eseguono in parallelo, calcolando indicatori e normalizzazioni al volo piuttosto che precalcolarli e memorizzarli.

TensorFlow Serving è un sistema di livello produzione per distribuire modelli dietro un'API gRPC o REST ad alte prestazioni. Gestisce il versioning dei modelli (servi il nuovo modello mantenendo il vecchio come fallback), il batching delle richieste (combina più richieste di inferenza per efficienza GPU), e l'accelerazione hardware — tutti critici per sistemi di trading dove sia la latenza che l'affidabilità contano.

# Esporta un SavedModel
model.save("models/price_predictor/1")

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

Un'architettura di produzione tipica: il tuo bot di trading si connette al feed WebSocket di GaiaEx, calcola feature in tempo reale, invia richieste di inferenza a TF Serving, e riceve predizioni in millisecondi a una cifra. Quando riaddestri su nuovi dati, distribuisci il modello aggiornato come versione 2 — TF Serving lo scambia dentro con zero downtime.

TensorFlow Lite comprime i modelli per la distribuzione su dispositivi mobili, sistemi embedded, e hardware edge. Tramite tecniche come la quantizzazione (convertire pesi in virgola mobile a 32 bit in interi a 8 bit), il pruning (rimuovere pesi quasi zero), e l'ottimizzazione dell'architettura, TF Lite può ridurre un modello di 4x o più preservando la maggior parte della sua accuratezza. Questo abilita l'esecuzione di inferenza direttamente su dispositivi con compute limitato — utile per nodi di trading edge o dashboard di monitoraggio che devono operare indipendentemente dall'infrastruttura cloud.

# Converti un modello Keras in 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 vs PyTorch — quale dovresti scegliere per applicazioni finanziarie?

• Per ricerca e prototipazione: PyTorch. I suoi grafi dinamici, l'API Pythonic, e la posizione dominante nella ricerca accademica significano che più paper includono codice PyTorch, più tutorial usano PyTorch, e il debug è più intuitivo.
• Per la distribuzione in produzione a scala: TensorFlow mantiene ancora vantaggi. TF Serving, TF Lite, e TensorFlow.js forniscono percorsi di distribuzione testati sul campo verso cui TorchServe e ONNX Runtime di PyTorch stanno ancora maturando.
• Per il ML finanziario specificamente: Inizia con PyTorch per lo sviluppo del modello e la sperimentazione. Se i tuoi requisiti di produzione richiedono la maturità di TF Serving o la distribuzione edge di TF Lite, convertiti i tuoi migliori modelli. Molti team usano PyTorch per la ricerca e TensorFlow per la distribuzione, collegandoli tramite il formato ONNX (Open Neural Network Exchange).

La verità onesta: entrambi i framework stanno convergendo. TensorFlow ha adottato l'eager execution; PyTorch ha aggiunto torch.compile per l'ottimizzazione a livello di grafo. Keras stesso ora supporta PyTorch, JAX, e TensorFlow come backend. Il miglior framework è quello che il tuo team conosce bene e con cui può distribuire codice di produzione. Scegline uno, padroneggialo, e risolvi il problema reale — predire i mercati — invece di discutere sugli strumenti.