← Retour au portfolio RSS

· 4 min de lecture

Keras : mon premier réseau de neurones

Étape 4 : réseaux denses, courbes d'apprentissage, convolutions et apprentissage par transfert.

Les réseaux de neurones prennent le relais là où le machine learning classique plafonne : images, texte, son, tout ce qui n’entre pas naturellement dans un tableau de colonnes. Keras est la porte d’entrée idéale : une API courte et lisible, qui laisse voir les idées sans noyer dans les détails. Depuis Keras 3, le même code tourne au choix sur TensorFlow, PyTorch ou JAX.

Ce qu’est vraiment un réseau de neurones

Une couche « dense » calcule exactement ce qu’on a vu avec NumPy, suivi d’une non-linéarité :

h = r e l u ( X W + b ) h = \mathrm{relu}(XW + b)

Empiler plusieurs couches permet d’apprendre des relations non linéaires. L’entraînement ajuste W W et b b par descente de gradient, la même idée que dans mon article sur la régression linéaire, généralisée à des millions de paramètres grâce à la rétropropagation.

Un premier réseau : reconnaître des chiffres manuscrits

Le jeu MNIST : 70 000 images de chiffres de 28 × 28 pixels.

import keras
from keras import layers

(x_train, y_train), (x_test, y_test) = keras.datasets.mnist.load_data()
x_train = x_train.reshape(-1, 784).astype("float32") / 255   # aplatir, ramener à [0, 1]
x_test = x_test.reshape(-1, 784).astype("float32") / 255

modele = keras.Sequential([
    keras.Input(shape=(784,)),
    layers.Dense(128, activation="relu"),
    layers.Dropout(0.2),
    layers.Dense(10, activation="softmax"),   # une probabilité par chiffre
])

modele.compile(
    optimizer="adam",
    loss="sparse_categorical_crossentropy",
    metrics=["accuracy"],
)

historique = modele.fit(x_train, y_train, epochs=10, batch_size=64, validation_split=0.1)
modele.evaluate(x_test, y_test)   # environ 98 % d'exactitude

Chaque élément mérite d’être compris, pas seulement recopié :

  • Dense(10, activation="softmax") : dix sorties dont la somme vaut 1, une probabilité par classe.
  • sparse_categorical_crossentropy : la perte adaptée quand les étiquettes sont des entiers (0 à 9).
  • adam : une descente de gradient qui adapte son pas à chaque paramètre.
  • Dropout(0.2) : éteint au hasard 20 % des neurones à l’entraînement, pour lutter contre le surapprentissage.
  • validation_split : garde 10 % des données d’entraînement pour surveiller la généralisation à chaque époque.

Lire les courbes d’apprentissage

import matplotlib.pyplot as plt

plt.plot(historique.history["loss"], label="entraînement")
plt.plot(historique.history["val_loss"], label="validation")
plt.legend(); plt.show()
  • Les deux pertes baissent ensemble : le modèle apprend.
  • La perte d’entraînement baisse mais celle de validation remonte : surapprentissage. Il faut arrêter plus tôt, régulariser ou ajouter des données.

Keras sait arrêter tout seul au bon moment :

arret = keras.callbacks.EarlyStopping(patience=3, restore_best_weights=True)
modele.fit(x_train, y_train, epochs=50, validation_split=0.1, callbacks=[arret])

Passer aux images : les convolutions

Aplatir une image jette sa structure spatiale. Une couche de convolution apprend des filtres (bords, textures, formes) qui glissent sur l’image :

x_train_img = x_train.reshape(-1, 28, 28, 1)

cnn = keras.Sequential([
    keras.Input(shape=(28, 28, 1)),
    layers.Conv2D(32, 3, activation="relu"),
    layers.MaxPooling2D(),
    layers.Conv2D(64, 3, activation="relu"),
    layers.MaxPooling2D(),
    layers.Flatten(),
    layers.Dense(10, activation="softmax"),
])

Même compilation, même entraînement : on dépasse 99 % sur MNIST, avec moins de paramètres que le réseau dense.

Réutiliser un modèle déjà entraîné

En pratique, on n’entraîne presque jamais un réseau de vision à partir de zéro. On part d’un modèle pré-entraîné sur des millions d’images et on n’ajuste que la fin : c’est l’apprentissage par transfert.

base = keras.applications.MobileNetV2(include_top=False, pooling="avg", input_shape=(160, 160, 3))
base.trainable = False   # on garde ce qu'il sait déjà

modele = keras.Sequential([base, layers.Dense(1, activation="sigmoid")])

Avec quelques centaines d’images par classe, on obtient un classifieur sérieux.

Projet pour valider l’étape

  1. MNIST avec un réseau dense, puis un réseau convolutif : comparer exactitude et nombre de paramètres.
  2. Tracer et interpréter les courbes d’apprentissage, provoquer volontairement un surapprentissage, puis le corriger.
  3. Construire un classifieur d’images à partir de ses propres photos (deux ou trois classes) par apprentissage par transfert.
  4. Sauvegarder le modèle (modele.save("modele.keras")) et le servir derrière une petite API, dans un conteneur Docker. C’est là que mon métier de développeur backend et infra rejoint l’IA.

Ressources