🧩 Keras – L'API "Humaine" du Deep Learning

Keras n'est **pas** un paquet séparé. Il est **inclus** dans tensorflow.

(Si vous voyez pip install keras, c'est l'ancienne version "multi-backend" ou le nouveau "Keras Core 3.0" qui est différent. Pour 99% des usages, on utilise tf.keras).

Installation (via TensorFlow)

# 1. (Recommandé) Créer un environnement virtuel
python -m venv tf_env
source tf_env/bin/activate

# 2. Installer TensorFlow (Keras est inclus)
pip install tensorflow

# 3. Import en Python
import tensorflow as tf
from tensorflow import keras
from tensorflow.keras import layers

print(tf.__version__)

C'est le "diagramme mental" de Keras. 90% des modèles suivent ce flux.

from tensorflow import keras
from tensorflow.keras import layers

# --- 1. Définir le Modèle (Architecture) ---
model = keras.Sequential([
    layers.Dense(64, activation='relu', input_shape=(784,)),
    layers.Dense(10, activation='softmax')
])

# --- 2. Compiler le Modèle (Configurer) ---
model.compile(
    optimizer='adam',
    loss='sparse_categorical_crossentropy',
    metrics=['accuracy']
)

# --- 3. Entraîner le Modèle (Apprentissage) ---
model.fit(
    x_train, 
    y_train, 
    epochs=5,
    batch_size=32,
    validation_data=(x_val, y_val)
)

# --- 4. Évaluer le Modèle (Test) ---
results = model.evaluate(x_test, y_test)
print(f"Test Loss: {results[0]}, Test Accuracy: {results[1]}")

# --- 5. Prédire (Inférence) ---
predictions = model.predict(x_new_data)

Le Sequential est le modèle le plus simple. C'est une pile linéaire de couches. (Parfait pour les CNN, MLP, et RNN simples).

Syntaxe 1 : Liste dans le constructeur (Préférée)

model = keras.Sequential([
    layers.Conv2D(32, (3,3), activation='relu', input_shape=(28, 28, 1)),
    layers.MaxPooling2D((2,2)),
    layers.Flatten(),
    layers.Dense(10, activation='softmax')
], name="mon_cnn_simple")

Syntaxe 2 : .add()

model = keras.Sequential(name="mon_cnn_simple")
model.add(layers.Conv2D(32, (3,3), activation='relu', input_shape=(28, 28, 1)))
model.add(layers.MaxPooling2D((2,2)))
model.add(layers.Flatten())
model.add(layers.Dense(10, activation='softmax'))

// Visualiser le modèle
model.summary()

L'API Fonctionnelle est utilisée pour les modèles complexes : graphes (non-linéaires), multi-input, multi-output, ou connexions résiduelles (ResNet).

L'idée : 1. Définir un Input. 2. "Appeler" les couches sur les Tensors. 3. Définir le Model.

Exemple (Multi-Input)

from tensorflow.keras import Model
from tensorflow.keras.layers import Input, Dense, concatenate

# 1. Définir les Entrées
input_A = Input(shape=(32,), name="Input_Texte")
input_B = Input(shape=(64,), name="Input_Metadata")

# 2. Branche A
x = Dense(16, activation='relu')(input_A)

# 3. Branche B
y = Dense(32, activation='relu')(input_B)

# 4. Combiner (Concaténer)
combined = concatenate([x, y])

# 5. Sortie
output = Dense(1, activation='sigmoid', name="Output")(combined)

# 6. Créer le Modèle
model = Model(inputs=[input_A, input_B], outputs=output)

model.summary()

Pour un contrôle total (ex: R&D), on peut hériter de keras.Model (similaire à nn.Module en PyTorch).

• __init__(self) : Définir les couches (qui ont des poids).
• call(self, x) : Définir le "forward pass" (la logique).

Exemple (Modèle simple)

class SimpleNet(keras.Model):
    
    def __init__(self):
        super(SimpleNet, self).__init__()
        # 1. Définir les couches
        self.dense1 = layers.Dense(64, activation='relu')
        self.dense2 = layers.Dense(10, activation='softmax')
        
    def call(self, inputs):
        # 2. Définir la logique "forward"
        x = self.dense1(inputs)
        return self.dense2(x)

# Instancier
model = SimpleNet()

Inconvénient : Plus difficile à déboguer et model.summary() ne montre pas les connexions (car défini en runtime).

(Pour les Réseaux de Neurones Convolutifs - Vision par Ordinateur)

(Pour les Réseaux Récurrents - NLP, Séries Temporelles)

model.fit() accepte plusieurs types d'entrées :

(x_train, y_train) = load_mnist_data()
// x_train est un array NumPy

model.fit(x_train, y_train, ...)

// (Voir le guide TensorFlow 4.2)
dataset = tf.data.Dataset.from_tensor_slices(...)
dataset = dataset.map(preprocess_fn)
dataset = dataset.batch(32)
dataset = dataset.prefetch(tf.data.AUTOTUNE)

model.fit(dataset, epochs=5)

Sauvegarder l'architecture ET les poids (weights) du modèle après l'entraînement.

# 1. Sauvegarder
model.save("mon_modele_dossier")

# 2. Charger
new_model = keras.models.load_model("mon_modele_dossier")

# 1. Sauvegarder (en spécifiant .h5)
model.save("mon_modele.h5")

# 2. Charger
new_model = keras.models.load_model("mon_modele.h5")

Loss (Perte) : Ce que le modèle doit minimiser. (L'erreur).

Metrics : Ce que l'on veut surveiller (pour les humains). Ex: metrics=['accuracy', 'mae'].

L'optimiseur est l'algorithme (Descente de Gradient) qui met à jour les poids pour minimiser la Loss.

// Syntaxe 1: String (avec défauts)
model.compile(optimizer='adam', ...)

// Syntaxe 2: Objet (pour changer le learning rate)
from tensorflow.keras.optimizers import Adam
model.compile(optimizer=Adam(learning_rate=0.001), ...)

model.fit() est la fonction qui lance la boucle d'entraînement (backpropagation).

history = model.fit(
    x_train,            // Données d'entraînement
    y_train,            // Labels d'entraînement
    epochs=10,          // (Combien de fois voir tout le dataset)
    batch_size=32,      // (Combien d'items par mise à jour des poids)
    validation_data=(x_val, y_val), // (Données pour évaluer (pas entraîner))
    # ou validation_split=0.2       // (Prend 20% de x_train pour val)
    callbacks=[...]     // (Actions (voir onglet 2))
)

from tensorflow.keras.callbacks import EarlyStopping, ModelCheckpoint

// (Arrête si 'val_loss' n'a pas baissé
// depuis 'patience'=3 epochs)
cb_early_stop = EarlyStopping(
    monitor='val_loss', 
    patience=3
)

// (Sauvegarde le meilleur modèle (basé sur 'val_loss'))
cb_checkpoint = ModelCheckpoint(
    filepath="best_model.h5",
    monitor='val_loss',
    save_best_only=True
)

model.fit(
    ...,
    callbacks=[cb_early_stop, cb_checkpoint]
)

Les "Callbacks" sont des "hooks" (points d'arrêt) appelés pendant .fit() (ex: à la fin de chaque epoch).

EarlyStopping (Essentiel) : Arrête l'entraînement si la performance (sur validation_data) stagne ou se dégrade (évite l'overfitting).

ModelCheckpoint : Sauvegarde le modèle (ex: uniquement le meilleur .h5).

from tensorflow.keras.callbacks import EarlyStopping, ModelCheckpoint

// (Arrête si 'val_loss' n'a pas baissé
// depuis 'patience'=3 epochs)
cb_early_stop = EarlyStopping(
    monitor='val_loss', 
    patience=3
)

// (Sauvegarde le meilleur modèle (basé sur 'val_loss'))
cb_checkpoint = ModelCheckpoint(
    filepath="best_model.h5",
    monitor='val_loss',
    save_best_only=True
)

model.fit(
    ...,
    callbacks=[cb_early_stop, cb_checkpoint]
)

L'écosystème Keras est (principalement) l'écosystème TensorFlow, qui utilise les modèles Keras comme entrée.

Keras (en tant que tf.keras) est utilisé par toutes les entreprises qui s'appuient sur l'écosystème TensorFlow pour le prototypage et la production.

Ressources pour apprendre et travailler avec Keras.