TensorFlow, Keras et TensorBoard pour le suivi de modèles

TensorFlow, développé par Google Brain et publié en 2015, n'est pas seulement une bibliothèque de deep learning — c'est un écosystème entier pour construire, entraîner, déployer et surveiller des modèles de machine learning à toute échelle. Alors que PyTorch domine la recherche, TensorFlow reste la puissance de la production, déployé dans des systèmes traitant des milliards de prédictions quotidiennes chez Google, Airbnb, Twitter, et des milliers d'autres entreprises.

L'écosystème couvre l'ensemble du cycle de vie du machine learning :

• Keras — L'API haut niveau pour construire et entraîner des modèles, maintenant entièrement intégrée à TensorFlow sous le nom tf.keras
• TensorBoard — Boîte à outils de visualisation pour surveiller l'entraînement, comparer les expériences et déboguer les modèles
• tf.data — Pipelines de données haute performance pour alimenter les modèles avec de grands ensembles de données
• TensorFlow Serving — Service de modèles de niveau production avec gestion des versions, regroupement de requêtes et accélération matérielle
• TensorFlow Lite — Environnement d'exécution optimisé pour les appareils mobiles et embarqués
• TensorFlow.js — Exécuter des modèles directement dans le navigateur

Cette étendue est la plus grande force de TensorFlow. Vous pouvez prototyper un modèle dans un notebook Jupyter avec Keras, l'entraîner sur un cluster de GPU, surveiller l'entraînement avec TensorBoard, le servir avec TF Serving derrière une API, et déployer une version compressée sur un Raspberry Pi — tout cela au sein du même framework. Pour des applications financières où vous pourriez avoir besoin de modèles fonctionnant à la fois dans un moteur de trading cloud (connecté à l'API de GaiaEx) et sur un poste de travail local pour la recherche, cette polyvalence compte.

Keras a été conçu selon un principe directeur : réduire la charge cognitive de la construction des réseaux de neurones. Il y parvient grâce à deux API de construction de modèles, chacune adaptée à différents niveaux de complexité.

L'API Sequential est la plus simple — une pile linéaire de couches :

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

Pour les modèles avec plusieurs entrées, plusieurs sorties, des couches partagées, ou des connexions résiduelles, l'API Functional vous offre un contrôle total au niveau du graphe :

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)

Ce modèle prend deux entrées — une séquence de prix sur 60 pas traitée par des LSTM empilés, et un vecteur de métadonnées de caractéristiques statiques — les combine, et produit une prédiction directionnelle. Cette architecture est courante dans le machine learning financier lorsque vous voulez mélanger des motifs temporels (action récente du prix) avec des informations contextuelles (régime de volatilité, taux de financement, jour de la semaine).

Types de couches clés pour les applications financières : Dense pour les caractéristiques tabulaires, LSTM et GRU pour les séries temporelles, Conv1D pour apprendre des motifs temporels locaux, et MultiHeadAttention pour la modélisation de séquences de type transformer.

Une fois construit, un modèle Keras doit être compilé avec trois composants : un optimiseur, une fonction de perte, et des métriques d'évaluation.

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

Les callbacks sont des points d'accroche qui s'exécutent à des moments précis durant l'entraînement — après chaque epoch, chaque lot, ou lorsque certaines conditions sont remplies. Ils automatisent la gestion de l'entraînement qui exigerait sinon une surveillance manuelle :

• EarlyStopping — Arrête l'entraînement lorsque la perte de validation cesse de s'améliorer pendant patience epochs. Empêche le surapprentissage et le calcul gaspillé. Réglez restore_best_weights=True pour revenir automatiquement au meilleur checkpoint.
• ModelCheckpoint — Sauvegarde le modèle chaque fois que la performance de validation s'améliore. Ne perdez jamais votre meilleur modèle à cause d'un crash d'entraînement ou d'un surapprentissage dans les epochs ultérieures.
• ReduceLROnPlateau — Réduit le taux d'apprentissage lorsque la perte de validation stagne. Cela débloque souvent une performance supplémentaire qu'un taux d'apprentissage fixe manque — le modèle fait de grands pas initialement, puis affine avec des pas plus petits.

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 est la boîte à outils de visualisation de TensorFlow, et c'est l'un des outils les plus précieux dans le flux de travail de tout praticien du machine learning — que vous utilisiez TensorFlow, PyTorch, ou JAX. Il transforme les journaux d'entraînement brut en tableaux de bord interactifs qui révèlent ce qui se passe à l'intérieur de votre modèle.

Lancez TensorBoard en le pointant vers votre répertoire de journaux :

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

# Ou dans un notebook Jupyter
%load_ext tensorboard
%tensorboard --logdir ./logs

Visualisations clés pour le développement de modèles financiers :

Scalars — Les courbes de perte d'entraînement et de validation tracées dans le temps. L'écart entre elles révèle le surapprentissage : une perte d'entraînement qui continue de diminuer tandis que la perte de validation augmente signifie que votre modèle mémorise le bruit. Un entraînement sain montre les deux courbes diminuant ensemble, avec la courbe de validation légèrement au-dessus de celle d'entraînement.

Histograms — Distributions des poids, biais et activations à travers les couches et les epochs. Surveillez les distributions de poids qui s'effondrent à zéro (gradients qui s'évanouissent), qui explosent vers de grandes valeurs (entraînement instable), ou les activations qui saturent à 0 ou 1 (neurones morts). Ces problèmes sont invisibles dans les courbes de perte mais évidents dans les histogrammes.

Embeddings — Projettent des représentations à haute dimension dans un espace 2D ou 3D à l'aide de t-SNE ou PCA. Visualisez si votre modèle a appris à séparer différents régimes de marché, classes d'actifs, ou états de volatilité dans ses représentations internes.

HParams — Comparez les balayages d'hyperparamètres à travers les expériences. Exécutez le même modèle avec différents taux d'apprentissage, architectures et valeurs de dropout, puis identifiez quelles combinaisons produisent les meilleures métriques de validation. Cette comparaison systématique remplace l'expérimentation ad hoc par une sélection de modèle fondée sur des preuves.

TensorBoard fonctionne également avec PyTorch via la classe torch.utils.tensorboard.SummaryWriter — les outils de visualisation sont indépendants du framework, ce qui explique en partie pourquoi TensorBoard est devenu un standard de facto dans l'ensemble de l'écosystème du machine learning.

Lorsque votre ensemble de données est trop volumineux pour tenir en mémoire — une situation courante lorsqu'on travaille avec des données tick par tick provenant de plateformes comme GaiaEx — tf.data fournit un pipeline de données efficace et parallélisé qui maintient votre GPU alimenté sans tout charger d'un coup.

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)
)

L'appel prefetch(AUTOTUNE) est essentiel — il permet au chargement des données et au calcul du modèle de se superposer, si bien que le GPU n'attend jamais inactif le lot suivant. Pour les ensembles de données financières avec une ingénierie de caractéristiques complexe, vous pouvez enchaîner des transformations .map() qui s'exécutent en parallèle, calculant les indicateurs et les normalisations à la volée plutôt que de les précalculer et de les stocker.

TensorFlow Serving est un système de niveau production pour déployer des modèles derrière une API gRPC ou REST haute performance. Il gère la gestion des versions de modèles (servir le nouveau modèle tout en conservant l'ancien comme solution de repli), le regroupement de requêtes (combiner plusieurs requêtes d'inférence pour l'efficacité GPU), et l'accélération matérielle — tous critiques pour les systèmes de trading où la latence et la fiabilité comptent toutes les deux.

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

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

Une architecture de production typique : votre bot de trading se connecte au flux WebSocket de GaiaEx, calcule les caractéristiques en temps réel, envoie des requêtes d'inférence à TF Serving, et reçoit des prédictions en quelques millisecondes. Lorsque vous réentraînez sur de nouvelles données, déployez le modèle mis à jour en tant que version 2 — TF Serving le remplace sans aucune interruption de service.

TensorFlow Lite compresse les modèles pour le déploiement sur appareils mobiles, systèmes embarqués et matériel edge. Grâce à des techniques comme la quantification (convertir des poids en virgule flottante 32 bits en entiers 8 bits), l'élagage (retirer les poids proches de zéro), et l'optimisation d'architecture, TF Lite peut réduire un modèle de 4 fois ou plus tout en préservant la plus grande partie de sa précision. Cela permet d'exécuter l'inférence directement sur des appareils à capacité de calcul limitée — utile pour les nœuds de trading edge ou les tableaux de bord de surveillance qui doivent fonctionner indépendamment de l'infrastructure cloud.

# Convertir un modèle Keras en 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 — lequel choisir pour les applications financières ?

• Pour la recherche et le prototypage : PyTorch. Ses graphes dynamiques, son API pythonique, et sa position dominante dans la recherche académique signifient que plus d'articles incluent du code PyTorch, plus de tutoriels utilisent PyTorch, et le débogage est plus intuitif.
• Pour le déploiement en production à grande échelle : TensorFlow conserve encore des avantages. TF Serving, TF Lite et TensorFlow.js offrent des chemins de déploiement éprouvés vers lesquels TorchServe et ONNX Runtime de PyTorch continuent de mûrir.
• Pour le machine learning financier spécifiquement : Commencez avec PyTorch pour le développement de modèles et l'expérimentation. Si vos exigences de production nécessitent la maturité de TF Serving ou le déploiement edge de TF Lite, convertissez vos meilleurs modèles. De nombreuses équipes utilisent PyTorch pour la recherche et TensorFlow pour le déploiement, en les reliant via le format ONNX (Open Neural Network Exchange).

La vérité honnête : les deux frameworks convergent. TensorFlow a adopté l'exécution eager ; PyTorch a ajouté torch.compile pour l'optimisation au niveau du graphe. Keras lui-même prend désormais en charge PyTorch, JAX et TensorFlow comme backends. Le meilleur framework est celui que votre équipe connaît bien et avec lequel elle peut livrer du code de production. Choisissez-en un, maîtrisez-le, et résolvez le problème réel — prédire les marchés — plutôt que de débattre des outils.