TensorFlow (v2.x) offre une exécution immédiate (eager execution), un écosystème complet (TensorBoard, TF Serving, TF Lite, TF.js) et une intégration profonde avec Keras. Keras est l’API de haut niveau, intuitive et modulaire, qui permet de construire des réseaux de neurones en quelques lignes. Que vous soyez débutant ou expert, TensorFlow/Keras accélère le prototypage et la mise en production. ISOSET propose des cursus pratiques pour maîtriser ces outils, des CNN aux transformers.

• TensorFlow 2.x – execution immédiate, compatible avec Keras intégré.
• Keras – API simple, modulaire, extensible.
• Écosystème – TensorBoard (visualisation), TF Data (pipeline optimisé), TF Serving (déploiement).

L’API Sequential est la plus simple : on ajoute des couches les unes après les autres. Elle convient à la plupart des architectures « feedforward » (perceptron multicouche, CNN, etc.). Chaque couche reçoit en entrée la sortie de la précédente.

# CNN simple avec Sequential
import tensorflow as tf
model = tf.keras.Sequential([
    tf.keras.layers.Conv2D(32, (3,3), activation='relu', input_shape=(28,28,1)),
    tf.keras.layers.MaxPooling2D((2,2)),
    tf.keras.layers.Conv2D(64, (3,3), activation='relu'),
    tf.keras.layers.MaxPooling2D((2,2)),
    tf.keras.layers.Flatten(),
    tf.keras.layers.Dense(64, activation='relu'),
    tf.keras.layers.Dense(10, activation='softmax')
])

ISOSET forme à la construction de modèles séquentiels pour la vision, la classification de textes et les séries temporelles.

L’API Fonctionnelle permet de construire des graphes plus complexes : modèles avec plusieurs entrées (ex: image + metadata), plusieurs sorties (classification + régression), des connexions résiduelles (ResNet) ou des branches partagées.

# Architecture multi‑entrée avec API Fonctionnelle
input_a = tf.keras.Input(shape=(32,))
input_b = tf.keras.Input(shape=(64,))
x = tf.keras.layers.Dense(32, activation='relu')(input_a)
y = tf.keras.layers.Dense(32, activation='relu')(input_b)
concat = tf.keras.layers.Concatenate()([x, y])
output = tf.keras.layers.Dense(1, activation='sigmoid')(concat)
model = tf.keras.Model(inputs=[input_a, input_b], outputs=output)

ISOSET enseigne l’API Fonctionnelle pour les architectures avancées (Siamese networks, Auto‑encodeurs).

La méthode `compile()` spécifie l’optimiseur (Adam, SGD, RMSprop), la fonction de perte (categorical_crossentropy, mse, binary_crossentropy) et les métriques de suivi (accuracy, AUC, precision, recall).

# Compilation d’un modèle de classification
model.compile(optimizer='adam',
              loss='sparse_categorical_crossentropy',
              metrics=['accuracy', tf.keras.metrics.AUC()])

Keras offre aussi des callbacks comme `ReduceLROnPlateau` (ajuster dynamiquement le taux d’apprentissage) et `TensorBoard` pour le suivi. ISOSET forme à l’optimisation des hyperparamètres.

La méthode `fit()` lance l’entraînement. On peut utiliser des callbacks pour arrêter l’entraînement prématurément (EarlyStopping), sauvegarder le meilleur modèle (ModelCheckpoint), ou visualiser les courbes d’apprentissage avec TensorBoard.

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

L’objet `history` contient les métriques à chaque époque, pour tracer les courbes d’apprentissage. ISOSET propose des ateliers interactifs pour analyser les courbes de loss et détecter le sur‑apprentissage.

Keras permet de sauvegarder le modèle entier (architecture + poids + état de l’optimiseur) au format HDF5 (.h5) ou SavedModel. On peut ensuite le recharger pour des prédictions ou le servir avec TensorFlow Serving, TF Lite (mobile/embarqué) ou TF.js (navigateur).

# Sauvegarde et chargement
model.save('mon_modele.keras')  # format Keras v3
restored = tf.keras.models.load_model('mon_modele.keras')
predictions = restored.predict(X_test)

ISOSET forme à l’intégration de modèles TensorFlow dans des APIs (FastAPI, Flask) et à l’utilisation de TensorFlow Serving.

Keras donne accès à des architectures pré‑entraînées sur ImageNet (ResNet, EfficientNet, MobileNet, VGG) via `tf.keras.applications`. On gèle les premières couches, on ajoute un nouveau classifieur, et on fine‑tune sur son jeu de données personnalisé. Idéal quand on a peu de données.

# Transfer learning avec MobileNetV2
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)

ISOSET recueille des témoignages d’apprenants ayant utilisé le transfer learning pour des projets de classification d’images médicales ou de défauts industriels.

• Normaliser les entrées – images en [0,1] ou standardisation.
• Utiliser la régularisation – Dropout, L2, BatchNormalization.
• Apprentissage par étapes – scheduler de learning rate, warmup.
• Monitorer les courbes – loss et métriques sur entraînement/validation.
• Augmentation des données – rotations, zoom, flip pour la vision.

Les témoignages d’anciens élèves d’ISOSET : *« La formation TensorFlow m’a permis de passer des notebooks de démo à des modèles déployés en production, avec des callbacks et du transfer learning. Aujourd’hui, je suis Machine Learning Engineer. »*