TensorFlow : le framework de deep learning au service de la production

Depuis son lancement par Google en 2015, TensorFlow s’est imposé comme la plateforme de deep learning la plus utilisée en industrie. Sa force réside dans sa capacité à passer du prototypage rapide à la production sur des clusters de milliers de machines. TensorFlow 2.x a simplifié l’API avec l’intégration native de Keras, l’exécution immédiate (eager execution) et un écosystème riche : TensorBoard, TensorFlow Lite (mobile et embarqué), TensorFlow.js (navigateur), TFX (MLOps) et TensorFlow Serving. La compréhension de ces briques est indispensable pour tout ingénieur ML souhaitant industrialiser ses modèles. L’organisme de formation ISOSET constate chaque jour que les praticiens qui maîtrisent TensorFlow déploient plus rapidement et avec moins d’erreurs. Cet article explore les concepts fondamentaux de TensorFlow, nourri par l’expérience pédagogique d’ISOSET.

1. TensorFlow 2.x : l’exécution immédiate et Keras intégré

Avant la version 2, TensorFlow reposait sur la construction statique de graphes (fonctionnement à la TensorFlow 1). TensorFlow 2 a rendu l’exécution eager (immédiate) par défaut, ce qui simplifie le débogage et la programmation : les opérations s’exécutent ligne par ligne, comme en Python standard. Par ailleurs, Keras a été élevé au rang d’API officielle de haut niveau, facile à prendre en main tout en restant extensible. Ces changements ont considérablement réduit la courbe d’apprentissage. Les ateliers d’ISOSET comparent les deux paradigmes pour illustrer les gains de productivité.

2. Le workflow Keras typique

Keras propose trois styles de construction de modèles :

Sequential – empilement linéaire de couches (le plus simple, adapté à la majorité des architectures feed‑forward).
API Fonctionnelle – modèles avec plusieurs entrées/sorties, branches partagées, connexions résiduelles.
Sous‑classes de tf.keras.Model – contrôle total, pour les architectures très spécifiques.

Exemple avec l’API Sequential :

python

import tensorflow as tf

model = tf.keras.Sequential([
    tf.keras.layers.Flatten(input_shape=(28,28)),
    tf.keras.layers.Dense(128, activation='relu'),
    tf.keras.layers.Dropout(0.2),
    tf.keras.layers.Dense(10, activation='softmax')
])

La compilation spécifie l’optimiseur, la perte et les métriques :

python

model.compile(optimizer='adam',
              loss='sparse_categorical_crossentropy',
              metrics=['accuracy'])

L’entraînement se fait avec model.fit(), l’évaluation avec model.evaluate() et la prédiction avec model.predict(). Ce workflow est enseigné dès les premiers modules d’ISOSET.

3. Couches essentielles et personnalisation

Keras fournit une large bibliothèque de couches :

Dense – couche entièrement connectée.
Conv2D, MaxPooling2D – pour la vision par ordinateur.
LSTM, GRU – pour les séquences.
BatchNormalization, Dropout – pour la régularisation.
Embedding – pour les données catégorielles ou textuelles.

On peut aussi créer ses propres couches en sous‑classant tf.keras.layers.Layer. Exemple d’une couche simplifiée :

python

class MonConv2D(tf.keras.layers.Layer):
    def __init__(self, filters, kernel_size):
        super().__init__()
        self.conv = tf.keras.layers.Conv2D(filters, kernel_size, activation='relu')

    def call(self, inputs):
        return self.conv(inputs)

La personnalisation est un sujet avancé abordé dans les formations spécialisées d’ISOSET.

4. Entraînement efficace : callbacks et early stopping

Les callbacks permettent d’intercepter l’entraînement en cours. Les plus utiles :

EarlyStopping – arrête l’entraînement quand la performance ne s’améliore plus sur la validation.
ModelCheckpoint – sauvegarde les meilleurs poids.
ReduceLROnPlateau – réduit le taux d’apprentissage en cas de plateau.
TensorBoard – enregistre les métriques pour visualisation.

Exemple :

python

callbacks = [
    tf.keras.callbacks.EarlyStopping(patience=5, restore_best_weights=True),
    tf.keras.callbacks.ModelCheckpoint('best_model.keras', save_best_only=True),
    tf.keras.callbacks.TensorBoard(log_dir='./logs')
]
model.fit(X_train, y_train, validation_data=(X_val, y_val),
          epochs=100, callbacks=callbacks)

L’utilisation des callbacks est systématiquement incluse dans les projets pratiques d’ISOSET.

5. TensorBoard : visualisation des métriques

TensorBoard est un tableau de bord interactif accessible via tensorboard --logdir ./logs. Il permet de :

visualiser les courbes de perte et d’accuracy (entraînement vs validation).
inspecter les histograms des poids et des gradients.
examiner le graphe du modèle.
projeter des embeddings.

Pour l’activer, il suffit d’ajouter le callback TensorBoard pendant l’entraînement. Les stagiaires d’ISOSET utilisent TensorBoard pour diagnostiquer le sur‑apprentissage et les problèmes de convergence.

6. Sauvegarde et chargement des modèles

Keras permet de sauvegarder l’intégralité du modèle (architecture, poids, état de l’optimiseur) au format .keras (recommandé) ou .h5. Le chargement est tout aussi simple.

python

model.save('mon_modele.keras')
restored = tf.keras.models.load_model('mon_modele.keras')

Pour ne sauvegarder que les poids : model.save_weights('poids.h5'). On peut aussi exporter au format SavedModel (utilisé par TensorFlow Serving). Les bonnes pratiques de versionnement des modèles sont enseignées par ISOSET.

7. Transfer learning avec Keras

Keras met à disposition des modèles pré‑entraînés sur ImageNet via tf.keras.applications. Le transfer learning permet d’adapter ces modèles à des tâches spécifiques avec peu de données. La procédure typique :

Charger un modèle de base sans la tête de classification (include_top=False).
Geler ses couches (base_model.trainable = False).
Ajouter une nouvelle tête de classification adaptée au nombre de classes cible.
Compiler et entraîner la tête.
Optionnellement, dégeler certaines couches pour un fine‑tuning avec un petit taux d’apprentissage.

Exemple de création d’un modèle de classification avec MobileNetV2 :

python

base_model = tf.keras.applications.MobileNetV2(
    input_shape=(224,224,3), include_top=False, weights='imagenet'
)
base_model.trainable = False

inputs = tf.keras.Input(shape=(224,224,3))
x = base_model(inputs, training=False)
x = tf.keras.layers.GlobalAveragePooling2D()(x)
outputs = tf.keras.layers.Dense(10, activation='softmax')(x)
model = tf.keras.Model(inputs, outputs)
model.compile(optimizer='adam', loss='sparse_categorical_crossentropy', metrics=['accuracy'])

Le transfer learning est couvert dans les modules avancés d’ISOSET.

8. TensorFlow Serving : déployer un modèle en production

Après l’entraînement, on met souvent le modèle à disposition via une API REST. TensorFlow Serving est un serveur haute performance spécialisé pour TensorFlow. Il gère le versionnement, le batching et la concurrence. Le déploiement se fait en quelques étapes :

Exporter le modèle au format SavedModel.
Lancer le serveur Docker tensorflow/serving.
Envoyer des requêtes gRPC ou HTTP.

bash

docker run -p 8501:8501 --mount type=bind,source=/path/to/model,target=/models/mon_modele -e MODEL_NAME=mon_modele -t tensorflow/serving

La prédiction s’effectue via curl -d '{"instances": [[...]]}' -X POST http://localhost:8501/v1/models/mon_modele:predict. Les formations ISOSET (https://www.isoset.fr/entreprises) incluent une mise en œuvre complète de Serving.

9. TensorFlow Lite pour l’edge et mobile

Pour les applications sur smartphone ou IoT, TensorFlow Lite convertit le modèle en un format léger (.tflite) avec quantification possible (réduction de précision). L’API d’inférence est optimisée pour les ressources limitées. Exemple de conversion :

python

converter = tf.lite.TFLiteConverter.from_keras_model(model)
tflite_model = converter.convert()
with open('model.tflite', 'wb') as f:
    f.write(tflite_model)

Ce format est utilisé dans les applications Android/iOS via les bibliothèques TensorFlow Lite. ISOSET (https://www.isoset.fr/formations/enfants-jeunes) propose des ateliers pour déployer un modèle de classification d’images sur un téléphone.

10. Bonnes pratiques pour TensorFlow

Utiliser tf.data pour des pipelines d’entrée performants (prélit, parallélisation, cache).
Mixer précision mixte (mixed_float16) accélère l’entraînement sur GPU compatibles.
Surveiller les fuites mémoire dans les boucles d’entraînement personnalisées.
Tester les differentielles (gradient checking) pour les couches personnalisées.
Versionner les jeux de données ainsi que les modèles.
Utiliser tf.function pour accélérer le code Python natif (compilation en graphe).

Ces pratiques sont enseignées dans le cursus avancé d’ISOSET.

11. Exemple complet : classification de chiffres MNIST

Un pipeline complet pour MNIST illustre la plupart des concepts :

python

import tensorflow as tf

# Chargement des données
(x_train, y_train), (x_test, y_test) = tf.keras.datasets.mnist.load_data()
x_train, x_test = x_train / 255.0, x_test / 255.0

# Construction
model = tf.keras.Sequential([
    tf.keras.layers.Flatten(input_shape=(28,28)),
    tf.keras.layers.Dense(128, activation='relu'),
    tf.keras.layers.Dropout(0.2),
    tf.keras.layers.Dense(10, activation='softmax')
])

# Compilation
model.compile(optimizer='adam',
              loss='sparse_categorical_crossentropy',
              metrics=['accuracy'])

# Entraînement avec callbacks
callbacks = [
    tf.keras.callbacks.EarlyStopping(patience=3, restore_best_weights=True),
    tf.keras.callbacks.TensorBoard(log_dir='./logs')
]
model.fit(x_train, y_train, epochs=20, validation_split=0.2, callbacks=callbacks)

# Évaluation
test_loss, test_acc = model.evaluate(x_test, y_test)
print(f'Test accuracy: {test_acc:.3f}')

# Sauvegarde
model.save('mnist_model.keras')

Cet exemple sert de base aux premiers travaux pratiques d’ISOSET.

TensorFlow est une plateforme mature et complète pour le deep learning, de la recherche à la production. Maîtriser son API Keras, l’entraînement avec callbacks, les fonctionnalités avancées (TensorBoard, Serving, Lite) et les bonnes pratiques de gestion des données est essentiel pour tout ingénieur ML. Les professionnels qui investissent dans ces compétences – grâce à des organismes de formation comme ISOSET – peuvent déployer des modèles fiables et performants, que ce soit sur serveur, mobile ou navigateur.