La reconnaissance d’image est une des applications les plus puissantes de l’intelligence artificielle. Elle est utilisée dans des domaines comme la santé (diagnostic médical), la surveillance, l’automobile (voitures autonomes) et bien plus encore.
Dans cet article, nous allons voir comment entraîner un modèle de reconnaissance d’images en utilisant TensorFlow et Keras. Nous explorerons les étapes suivantes :
✔️ Préparation des données
✔️ Construction du modèle
✔️ Entraînement et évaluation
✔️ Amélioration des performances
1. Prérequis et Installation des Bibliothèques
Avant de commencer, assurez-vous d’avoir Python (3.7+) installé sur votre machine, ainsi que les bibliothèques nécessaires.
📌 Installation des dépendances avec pip
bashCopierModifierpip install tensorflow keras numpy matplotlib opencv-python scikit-learn
2. Préparation des Données d’Entraînement
Nous allons utiliser le dataset CIFAR-10, qui contient 60 000 images réparties en 10 classes (chats, chiens, avions, etc.).
📌 Chargement des données CIFAR-10 avec TensorFlow
pythonCopierModifierimport tensorflow as tf
from tensorflow.keras.datasets import cifar10
import matplotlib.pyplot as plt
# Chargement du dataset
(x_train, y_train), (x_test, y_test) = cifar10.load_data()
# Affichage de quelques images
fig, axes = plt.subplots(1, 5, figsize=(10, 5))
for i in range(5):
axes[i].imshow(x_train[i])
axes[i].axis("off")
plt.show()
# Normalisation des valeurs des pixels (0-255 → 0-1)
x_train, x_test = x_train / 255.0, x_test / 255.0
✅ Pourquoi normaliser les images ?
👉 Pour améliorer l’apprentissage du réseau de neurones et accélérer la convergence.
3. Construction du Modèle de Reconnaissance d’Image
Nous allons utiliser un réseau de neurones convolutionnels (CNN), une architecture particulièrement adaptée à la reconnaissance d’images.
📌 Architecture du modèle :
- Conv2D + ReLU + MaxPooling pour extraire les caractéristiques des images
- Dense (Fully Connected Layer) pour classifier les images
- Softmax pour obtenir des probabilités par classe
Définition du modèle avec TensorFlow/Keras
pythonCopierModifierfrom tensorflow.keras.models import Sequential
from tensorflow.keras.layers import Conv2D, MaxPooling2D, Flatten, Dense, Dropout
# Définition du modèle CNN
model = Sequential([
Conv2D(32, (3,3), activation='relu', input_shape=(32,32,3)),
MaxPooling2D((2,2)),
Conv2D(64, (3,3), activation='relu'),
MaxPooling2D((2,2)),
Conv2D(128, (3,3), activation='relu'),
MaxPooling2D((2,2)),
Flatten(),
Dense(128, activation='relu'),
Dropout(0.5),
Dense(10, activation='softmax') # 10 classes dans CIFAR-10
])
# Compilation du modèle
model.compile(optimizer='adam',
loss='sparse_categorical_crossentropy',
metrics=['accuracy'])
# Affichage du résumé du modèle
model.summary()
✅ Pourquoi utiliser Adam comme optimiseur ?
👉 Il ajuste dynamiquement le taux d’apprentissage et accélère la convergence.
✅ Pourquoi utiliser Dropout ?
👉 Pour éviter le surapprentissage en désactivant aléatoirement des neurones pendant l’entraînement.
4. Entraînement du Modèle
📌 Lancement de l’apprentissage du modèle
pythonCopierModifierhistory = model.fit(x_train, y_train, epochs=10, batch_size=64, validation_data=(x_test, y_test))
✅ Pourquoi utiliser validation_data ?
👉 Pour évaluer les performances du modèle à chaque époque et éviter l’overfitting.
📌 Affichage de l’évolution de la précision et de la perte
pythonCopierModifierimport matplotlib.pyplot as plt
plt.plot(history.history['accuracy'], label='Train Accuracy')
plt.plot(history.history['val_accuracy'], label='Validation Accuracy')
plt.xlabel('Époques')
plt.ylabel('Précision')
plt.legend()
plt.show()
5. Évaluation et Test du Modèle
📌 Évaluer le modèle sur les données de test
pythonCopierModifiertest_loss, test_acc = model.evaluate(x_test, y_test, verbose=2)
print(f'Précision du modèle sur le jeu de test : {test_acc * 100:.2f}%')
📌 Tester le modèle sur une image aléatoire
pythonCopierModifierimport numpy as np
# Sélection d'une image aléatoire du test set
index = np.random.randint(len(x_test))
image = x_test[index]
label = y_test[index]
# Prédiction
prediction = model.predict(np.expand_dims(image, axis=0))
predicted_label = np.argmax(prediction)
# Affichage du résultat
plt.imshow(image)
plt.title(f"Vrai: {label[0]}, Prédit: {predicted_label}")
plt.axis("off")
plt.show()
✅ Pourquoi utiliser np.expand_dims ?
👉 Pour transformer l’image en un format compatible avec l’entrée du modèle.
6. Améliorer les Performances du Modèle
Si la précision du modèle n’est pas satisfaisante, voici quelques techniques pour l’améliorer :
🔹 Augmentation de données : générer des images modifiées pour enrichir l’apprentissage.
pythonCopierModifierfrom tensorflow.keras.preprocessing.image import ImageDataGenerator
datagen = ImageDataGenerator(
rotation_range=20,
width_shift_range=0.2,
height_shift_range=0.2,
horizontal_flip=True
)
datagen.fit(x_train)
🔹 Augmenter le nombre d’époques pour un meilleur apprentissage.
pythonCopierModifierhistory = model.fit(datagen.flow(x_train, y_train, batch_size=64),
epochs=30,
validation_data=(x_test, y_test))
🔹 Utiliser un modèle pré-entraîné (Transfer Learning) comme ResNet, MobileNet ou VGG16 pour des performances optimales.
pythonCopierModifierfrom tensorflow.keras.applications import VGG16
base_model = VGG16(weights='imagenet', include_top=False, input_shape=(32,32,3))
base_model.trainable = False # Gèle les poids du modèle pré-entraîné
✅ Pourquoi utiliser Transfer Learning ?
👉 Pour bénéficier des poids appris sur des millions d’images, ce qui accélère l’apprentissage et améliore la précision.
7. Déploiement du Modèle
Une fois satisfait du modèle, vous pouvez :
✔️ Exporter le modèle
pythonCopierModifiermodel.save("mon_modele_cnn.h5")
✔️ L’intégrer dans une application web avec Flask ou FastAPI.
pythonCopierModifierfrom flask import Flask, request, jsonify
import tensorflow as tf
app = Flask(__name__)
model = tf.keras.models.load_model("mon_modele_cnn.h5")
@app.route("/predict", methods=["POST"])
def predict():
img = request.files["image"]
img = preprocess_image(img) # À implémenter
prediction = model.predict(img)
return jsonify({"classe_predite": int(np.argmax(prediction))})
app.run(debug=True)
Conclusion
Nous avons vu comment :
✔️ Préparer et normaliser les images
✔️ Créer un modèle CNN avec TensorFlow
✔️ L’entraîner et l’évaluer
✔️ Améliorer les performances avec Data Augmentation et Transfer Learning
✔️ Déployer le modèle dans une application
