Keras est devenue l’interface de référence pour construire des réseaux de neurones en Python. Conçue à l’origine par François Chollet comme une bibliothèque indépendante, Keras est aujourd’hui intégrée officiellement dans TensorFlow (tf.keras). Sa philosophie : rendre le deep learning accessible sans sacrifier la flexibilité pour les cas avancés. Keras repose sur quelques concepts clés : les couches (layers), les modèles (Sequential ou API fonctionnelle), la compilation (optimiseur, perte, métriques), l’entraînement (fit, callbacks), et le déploiement (sauvegarde, conversion). Sans leur maîtrise, le prototypage d’architectures complexes devient fastidieux. L’organisme de formation ISOSET observe chaque jour que les data scientists qui maîtrisent Keras itèrent plus vite et produisent des modèles plus robustes.
1. Qu’est‑ce que Keras ?
Keras est une API de haut niveau pour construire et entraîner des modèles de deep learning. Elle agit comme une couche d’abstraction au‑dessus des moteurs de calcul (TensorFlow, anciennement Theano, CNTK). Depuis TensorFlow 2.x, tf.keras est l’implémentation officielle et recommandée, bénéficiant de l’intégration avec tf.data, tf.distribute et tf.saved_model. Keras se caractérise par :
- Simplicité – une API cohérente avec des blocs prédéfinis.
- Modularité – les couches, fonctions de perte, optimiseurs sont des composants interchangeables.
- Extensibilité – possibilité de créer ses propres couches, métriques, callbacks.
L’approche de Keras est de masquer la complexité sans enfermer l’utilisateur. Les formations ISOSET commencent toujours par Keras avant d’aborder les personnalisations avancées.
2. Le modèle Sequential : empiler des couches
Le Sequential est le type de modèle le plus simple. Il correspond à une pile linéaire de couches, où chaque couche a exactement une entrée et une sortie. Il est parfait pour les réseaux feed‑forward classiques.
python
import tensorflow as tf
model = tf.keras.Sequential([
tf.keras.layers.Dense(64, activation='relu', input_shape=(784,)),
tf.keras.layers.Dropout(0.5),
tf.keras.layers.Dense(10, activation='softmax')
])
On peut aussi ajouter des couches progressivement avec model.add(). La première couche doit préciser input_shape. Une fois le modèle construit, on le compile avec :
python
model.compile(optimizer='adam',
loss='categorical_crossentropy',
metrics=['accuracy'])
Les ateliers d’ISOSET utilisent le modèle Sequential pour des classifications d’images (MNIST, CIFAR‑10) et des régressions simples.
3. L’API fonctionnelle : modèles à branchements multiples
Lorsque le modèle n’est pas linéaire (entrées multiples, sorties multiples, connexions résiduelles, partage de couches), l’API fonctionnelle est indispensable. Elle traite les couches comme des fonctions appelables.
Exemple d’un modèle avec deux entrées (un texte et une image) fusionnées :
python
input_a = tf.keras.Input(shape=(100,), name='text') input_b = tf.keras.Input(shape=(28,28), name='image') x = tf.keras.layers.Dense(32, activation='relu')(input_a) y = tf.keras.layers.Flatten()(input_b) y = tf.keras.layers.Dense(32, activation='relu')(y) 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)
L’API fonctionnelle est également utilisée pour créer des architectures comme ResNet (connexions “skip”), Inception ou Siamese networks. Les professionnels formés par ISOSET maîtrisent cette API pour concevoir des réseaux non linéaires complexes.
4. Compilation : optimiseur, perte, métriques
La méthode compile paramètre le processus d’apprentissage :
- Optimiseur – algorithme de descente de gradient (
'adam','sgd','rmsprop'). On peut aussi passer une instance avec un taux d’apprentissage personnalisé. - Fonction de perte (loss) – mesure à minimiser (
'categorical_crossentropy','mse','binary_crossentropy'). - Métriques – indicateurs supplémentaires suivis pendant l’entraînement (
accuracy,AUC,precision,recall).
Exemple avec un optimiseur configurable :
python
optimizer = tf.keras.optimizers.Adam(learning_rate=0.001)
model.compile(optimizer=optimizer,
loss='sparse_categorical_crossentropy',
metrics=['accuracy', tf.keras.metrics.Precision()])
Le choix de la perte dépend de la tâche (classification binaire, multi‑classe, régression). Les métriques aident à surveiller les performances en validation. Les conseils de ISOSET (https://www.isoset.fr/formateurs) guident les apprenants vers les combinaisons adaptées à chaque problème.
5. Entraînement : fit et ses callbacks
L’entraînement s’effectue avec model.fit(). On peut passer les données sous forme de tableaux NumPy, de tf.data.Dataset ou de générateurs. Les paramètres essentiels :
epochs– nombre de passages complets.batch_size– nombre d’échantillons par mise à jour.validation_dataouvalidation_split– pour surveiller les performances hors entraînement.callbacks– listes d’actions pendant l’entraînement.
python
history = model.fit(x_train, y_train,
batch_size=32,
epochs=50,
validation_split=0.2,
callbacks=[
tf.keras.callbacks.EarlyStopping(patience=5, restore_best_weights=True),
tf.keras.callbacks.ModelCheckpoint('best.keras', save_best_only=True),
tf.keras.callbacks.TensorBoard(log_dir='./logs')
])
L’objet history contient les métriques par époque, ce qui permet de tracer les courbes d’apprentissage. Les callbacks sont un levier puissant pour automatiser l’arrêt précoce, la réduction du taux d’apprentissage ou la gestion des checkpoints. Les ateliers d’ISOSET mettent systématiquement en œuvre ces bonnes pratiques.
6. Couches prédéfinies et couches personnalisées
Keras propose des dizaines de couches prêtes à l’emploi :
- Dense – connexion complète.
- Conv2D, MaxPooling2D – convolution et pooling pour les images.
- LSTM, GRU, SimpleRNN – pour les séquences temporelles.
- Dropout, BatchNormalization – techniques de régularisation.
- Embedding – pour les représentations de mots.
- Flatten, GlobalAveragePooling2D – pour aplatir les sorties.
Si une fonctionnalité manque, il est facile de créer une couche personnalisée en sous‑classant tf.keras.layers.Layer. Il suffit d’implémenter __init__ (définition des variables) et call (logique de passage avant). Exemple d’une couche qui normalise les entrées :
python
class MyNormalization(tf.keras.layers.Layer):
def call(self, inputs):
mean, variance = tf.nn.moments(inputs, axes=[-1], keepdims=True)
return (inputs - mean) / tf.sqrt(variance + 1e-6)
Cette extensibilité fait la force de Keras en recherche. ISOSET (https://www.isoset.fr/temoignages) fournit des études de cas de couches personnalisées pour des besoins métiers spécifiques.
7. Sauvegarde et chargement d’un modèle
Keras offre plusieurs formats de sauvegarde :
- Format
.keras(recommandé) – contient l’architecture, les poids, l’état de l’optimiseur, la configuration de compilation. - Format SavedModel – répertoire contenant le binaire et les assets, compatible avec TensorFlow Serving.
- Fichier HDF5 (
.h5) – historique, mais moins complet.
python
# Sauvegarde
model.save('mon_modele.keras')
# Chargement
restored = tf.keras.models.load_model('mon_modele.keras')
Le modèle chargé peut immédiatement être utilisé pour prédire ou reprendre l’entraînement (l’optimiseur conserve ses moments). Les ingénieurs formés par ISOSET utilisent ces formats pour archiver leurs expériences et déployer en production.
8. Transfer learning avec Keras
Keras intègre des modèles pré‑entraînés dans tf.keras.applications. Disponibles pour la vision (VGG, ResNet, Inception, EfficientNet, MobileNet) et pour le NLP (BERT via des extensions). La procédure standard de transfer learning :
- Charger un modèle de base sans la tête de classification (
include_top=False). - Geler ses couches (
base_model.trainable = False). - Ajouter des couches de pooling puis une nouvelle tête de classification.
- Entraîner la tête seule.
- Optionnellement dégeler certaines couches pour du fine‑tuning avec un faible taux d’apprentissage.
Exemple avec MobileNetV2 sur un dataset personnalisé :
python
base = tf.keras.applications.MobileNetV2(input_shape=(224,224,3), include_top=False, weights='imagenet') base.trainable = False inputs = tf.keras.Input(shape=(224,224,3)) x = base(inputs, training=False) x = tf.keras.layers.GlobalAveragePooling2D()(x) outputs = tf.keras.layers.Dense(5, activation='softmax')(x) model = tf.keras.Model(inputs, outputs) model.compile(optimizer='adam', loss='categorical_crossentropy', metrics=['accuracy']) model.fit(...)
Le transfer learning est enseigné en détail par ISOSET (https://www.isoset.fr/entreprises).
9. Keras avec tf.data pour les grandes données
Pour des jeux de données dépassant la mémoire, tf.data est recommandé. On peut construire un pipeline d’entrée performant avec chargement paresseux, prélecture, parallélisation et cache. Exemple minimal :
python
dataset = tf.data.Dataset.from_tensor_slices((filenames, labels)) dataset = dataset.map(load_and_preprocess, num_parallel_calls=tf.data.AUTOTUNE) dataset = dataset.batch(32).prefetch(tf.data.AUTOTUNE) model.fit(dataset, epochs=10)
Cette combinaison Keras + tf.data est la voie standard pour l’utilisation de grands jeux de données. Les ateliers d’ISOSET montrent comment construire ces pipelines en évitant les goulets d’étranglement.
10. Bonnes pratiques avec Keras
- Commencer simple – un modèle Sequential avec quelques couches Dense donne une baseline.
- Valider avec EarlyStopping – éviter le sur‑apprentissage.
- Normaliser les entrées – en division par 255 pour les images, ou par standardisation.
- Utiliser
validation_splitou un jeu de validation explicite pour ajuster les hyperparamètres. - Exploiter TensorBoard pour visualiser l’évolution des métriques.
- Versionner les modèles via la convention de nommage des fichiers sauvegardés.
- Écrire des tests pour les couches personnalisées (vérifier la forme des sorties, la stabilité numérique).
Ces pratiques sont systématiquement mises en œuvre dans les projets d’ISOSET.
11. Exemple complet : classification de fleurs Iris
Le jeu de données Iris (petit, classique) illustre un workflow complet avec Keras :
python
import numpy as np
import tensorflow as tf
from sklearn.datasets import load_iris
from sklearn.model_selection import train_test_split
from sklearn.preprocessing import StandardScaler
# Données
data = load_iris()
X, y = data.data, data.target
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2, random_state=42)
# Normalisation
scaler = StandardScaler()
X_train = scaler.fit_transform(X_train)
X_test = scaler.transform(X_test)
# Modèle
model = tf.keras.Sequential([
tf.keras.layers.Dense(16, activation='relu', input_shape=(4,)),
tf.keras.layers.Dense(8, activation='relu'),
tf.keras.layers.Dense(3, activation='softmax')
])
model.compile(optimizer='adam', loss='sparse_categorical_crossentropy', metrics=['accuracy'])
# Entraînement
history = model.fit(X_train, y_train, validation_split=0.2, epochs=50, verbose=0,
callbacks=[tf.keras.callbacks.EarlyStopping(patience=5)])
# Évaluation
loss, acc = model.evaluate(X_test, y_test)
print(f'Test accuracy: {acc:.3f}')
Cet exemple, bien que simple, reprend les principales étapes : chargement, préparation, construction, compilation, entraînement avec callback, évaluation. Les débutants en ISOSET (https://www.isoset.fr/formations/grand-public) réalisent ce genre d’exercice dès la première journée.
Conclusion
Keras est l’outil idéal pour débuter en deep learning tout en restant suffisamment puissant pour des projets industriels complexes. Sa simplicité d’utilisation ne doit pas masquer sa capacité à construire des architectures avancées, à gérer le transfer learning et à s’intégrer avec l’écosystème TensorFlow. Maîtriser l’API Sequential, l’API fonctionnelle, les callbacks, la sauvegarde et le transfer learning sont des compétences clés pour tout data scientist ou ingénieur ML. Les professionnels qui les acquièrent – grâce à des formations de qualité comme celles d’ISOSET – peuvent itérer rapidement, éviter les erreurs courantes et déployer des modèles fiables en production.
© ISOSET — Organisme de formation professionnelle
LinkedIn | Facebook | Instagram