Passer à un framework de production : Keras

Les cinq leçons précédentes ont construit un réseau de neurones entièrement à la main. Cette dernière leçon referme la boucle : la même logique (couches, activation, rétropropagation, descente de gradient), déléguée à un framework de production.

Le jeu de données : Fashion-MNIST

Plutôt que les chiffres manuscrits MNIST (un cas académique très connu), ce cours utilise Fashion-MNIST : 60 000 images de 28×28 pixels représentant des articles vestimentaires (t-shirt, pantalon, pull, robe, manteau, sandale, chemise, basket, sac, bottine), un cas un peu plus proche d’un usage retail réel, avec la même API de chargement que MNIST.

from tensorflow import keras

(X_train, y_train), (X_test, y_test) = keras.datasets.fashion_mnist.load_data()
print("Forme train:", X_train.shape, "Forme test:", X_test.shape)

Forme train: (60000, 28, 28) Forme test: (10000, 28, 28)

Normaliser, encore et toujours

X_train = X_train / 255.0
X_test = X_test / 255.0

Même principe que la standardisation des modules précédents : ramener les pixels de l’intervalle [0, 255] à [0, 1] stabilise et accélère l’entraînement — la leçon 3 en a donné la justification mathématique précise (le conditionnement de la matrice de features).

Construire le réseau avec l’API Sequential

model = keras.Sequential([
    keras.layers.Flatten(input_shape=(28, 28)),
    keras.layers.Dense(128, activation="relu"),
    keras.layers.Dense(10),  # logits, pas de softmax ici
])

model.compile(
    optimizer="adam",
    loss=keras.losses.SparseCategoricalCrossentropy(from_logits=True),
    metrics=["accuracy"],
)

Trois lignes remplacent tout ce que les leçons 4 et 5 ont codé à la main : Flatten aplatit chaque image 28×28 en un vecteur de 784 valeurs (l’équivalent de la matrice de design des modules précédents), Dense(128, activation="relu") est une couche cachée pleinement connectée, Dense(10) produit un score par classe (10 catégories de vêtements). from_logits=True indique que la couche de sortie ne normalise pas encore ses scores en probabilités — un choix numériquement plus stable que d’appliquer un softmax avant le calcul de la perte.

Entraîner

history = model.fit(X_train, y_train, epochs=5, validation_split=0.1, verbose=2)

Epoch 1/5
1688/1688 - 4s - 3ms/step - accuracy: 0.8217 - loss: 0.5058 - val_accuracy: 0.8357 - val_loss: 0.4499
Epoch 2/5
1688/1688 - 4s - 2ms/step - accuracy: 0.8634 - loss: 0.3800 - val_accuracy: 0.8553 - val_loss: 0.3960
Epoch 3/5
1688/1688 - 4s - 2ms/step - accuracy: 0.8751 - loss: 0.3403 - val_accuracy: 0.8643 - val_loss: 0.3798
Epoch 4/5
1688/1688 - 4s - 2ms/step - accuracy: 0.8850 - loss: 0.3142 - val_accuracy: 0.8718 - val_loss: 0.3667
Epoch 5/5
1688/1688 - 4s - 2ms/step - accuracy: 0.8918 - loss: 0.2947 - val_accuracy: 0.8723 - val_loss: 0.3743

validation_split=0.1 réserve automatiquement 10 % du train pour suivre, à chaque epoch, une courbe train/test — exactement le réflexe de la leçon 2, ici fourni nativement par Keras.

Évaluer et faire une vraie prédiction

test_loss, test_acc = model.evaluate(X_test, y_test, verbose=0)
print("Test accuracy:", round(test_acc, 4))

Test accuracy: 0.8636

Pour obtenir de vraies probabilités (et non des logits bruts), on enchaîne le modèle entraîné avec une couche Softmax dédiée à l’inférence :

probability_model = keras.Sequential([model, keras.layers.Softmax()])
predictions = probability_model.predict(X_test[:5])

for i in range(5):
    print(class_names[y_test[i]], "->", class_names[predictions[i].argmax()])

vrai=Bottine      predit=Bottine      confiance=0.943
vrai=Pull         predit=Pull         confiance=0.999
vrai=Pantalon     predit=Pantalon     confiance=1.000
vrai=Pantalon     predit=Pantalon     confiance=1.000
vrai=Chemise      predit=T-shirt/top  confiance=0.490

Quatre prédictions sur cinq sont correctes, avec une confiance souvent proche de 1 — et une erreur honnête sur la cinquième (une chemise confondue avec un t-shirt), avec une confiance basse (49 %) qui reflète l’ambiguïté réelle entre ces deux catégories visuellement proches. Un modèle bien calibré se trompe parfois, mais idéalement avec moins d’assurance sur ses erreurs que sur ses bonnes réponses.

Bilan du module

Ce module a construit, dans l’ordre : un neurone unique (régression logistique), le suivi d’un entraînement par des courbes train/test, une explication quantitative du rôle de la standardisation (conditionnement de la matrice de features), un réseau à 2 couches pour dépasser la séparation linéaire, sa généralisation à N couches, et enfin la même famille de modèles reproduite avec un framework de production. Cette progression — from scratch, puis framework — reprend exactement le principe déjà appliqué au module 3 pour la régression et la classification classiques.

Prochaine étape

👉 Module 7 : Vision par ordinateur

---

Junior TSAFACK – 12/09/2026