Le Deep Learning (apprentissage profond) est une branche du Machine Learning qui repose sur des réseaux de neurones artificiels. Grâce à TensorFlow, un framework puissant développé par Google, il est possible d’entraîner des modèles pour diverses tâches comme la classification d’images, le traitement du langage naturel (NLP) et bien plus encore.
Dans cet article, nous allons voir comment entraîner un modèle de Deep Learning avec TensorFlow, en passant par toutes les étapes essentielles : préparation des données, construction du modèle, entraînement, évaluation et déploiement.
1. Installation et Importation des Bibliothèques
Avant de commencer, assurez-vous que TensorFlow est installé. Si ce n’est pas le cas, installez-le avec la commande :
bashCopierModifierpip install tensorflow
Ensuite, importez les bibliothèques nécessaires :
pythonCopierModifierimport tensorflow as tf
from tensorflow import keras
import numpy as np
import matplotlib.pyplot as plt
2. Chargement et Préparation des Données
Nous allons entraîner un modèle sur Fashion MNIST, un ensemble de données contenant 70 000 images de vêtements en niveaux de gris, classées en 10 catégories.
Chargement des données
pythonCopierModifier# Charger le dataset Fashion MNIST
fashion_mnist = keras.datasets.fashion_mnist
(train_images, train_labels), (test_images, test_labels) = fashion_mnist.load_data()
# Affichage de quelques images
plt.figure(figsize=(10, 5))
for i in range(10):
plt.subplot(2, 5, i+1)
plt.imshow(train_images[i], cmap="gray")
plt.axis("off")
plt.show()
Normalisation des données
Les valeurs des pixels vont de 0 à 255. Il est recommandé de les normaliser en les divisant par 255 pour accélérer l’entraînement :
pythonCopierModifiertrain_images = train_images / 255.0
test_images = test_images / 255.0
3. Construction du Modèle
Nous allons construire un réseau de neurones avec TensorFlow et Keras. Le modèle sera constitué de :
- Une couche Flatten pour convertir l’image 28×28 en un vecteur de 784 valeurs
- Une couche Dense (128 neurones, activation ReLU) pour apprendre des représentations
- Une couche Dense (10 neurones, activation softmax) pour la classification
pythonCopierModifiermodel = keras.Sequential([
keras.layers.Flatten(input_shape=(28, 28)), # Conversion de 28x28 en 1D
keras.layers.Dense(128, activation='relu'), # Couche cachée avec 128 neurones
keras.layers.Dense(10, activation='softmax') # Couche de sortie (10 classes)
])
Compilation du modèle
Avant l’entraînement, il faut compiler le modèle en précisant :
✅ L’optimiseur (Adam, très utilisé en Deep Learning)
✅ La fonction de perte (categorical_crossentropy pour la classification multi-classes)
✅ Les métriques pour évaluer les performances
pythonCopierModifiermodel.compile(optimizer='adam',
loss='sparse_categorical_crossentropy',
metrics=['accuracy'])
4. Entraînement du Modèle
L’entraînement consiste à montrer les images au modèle et lui permettre d’ajuster ses poids grâce à la rétropropagation.
pythonCopierModifierhistory = model.fit(train_images, train_labels, epochs=10, validation_data=(test_images, test_labels))
Explication des paramètres :
🔹 train_images, train_labels → Données d’entraînement
🔹 epochs=10 → Nombre d’itérations sur l’ensemble des données
🔹 validation_data → Données de test pour mesurer la performance
5. Évaluation du Modèle
Après l’entraînement, testons le modèle sur l’ensemble de test :
pythonCopierModifiertest_loss, test_acc = model.evaluate(test_images, test_labels)
print(f"Précision sur l’ensemble de test : {test_acc * 100:.2f}%")
L’exactitude (accuracy) indique combien d’images ont été correctement classifiées.
6. Prédictions avec le Modèle
Essayons de prédire la catégorie d’une image :
pythonCopierModifierpredictions = model.predict(test_images)
predicted_label = np.argmax(predictions[0]) # Trouver la classe avec la probabilité la plus élevée
print(f"Classe prédite : {predicted_label}")
Affichage de l’image et de la prédiction
pythonCopierModifierplt.imshow(test_images[0], cmap="gray")
plt.title(f"Prédiction : {predicted_label}")
plt.axis("off")
plt.show()
7. Amélioration du Modèle
Si la précision du modèle est trop faible, voici quelques stratégies d’amélioration :
✅ Ajout de couches supplémentaires
On peut ajouter des couches convolutives (CNN) pour mieux capter les caractéristiques des images.
pythonCopierModifiermodel = keras.Sequential([
keras.layers.Conv2D(32, (3, 3), activation='relu', input_shape=(28, 28, 1)),
keras.layers.MaxPooling2D((2, 2)),
keras.layers.Flatten(),
keras.layers.Dense(128, activation='relu'),
keras.layers.Dense(10, activation='softmax')
])
✅ Augmentation des données
L’augmentation des données (rotation, zoom, miroir) améliore la généralisation.
pythonCopierModifierfrom tensorflow.keras.preprocessing.image import ImageDataGenerator
datagen = ImageDataGenerator(
rotation_range=10,
width_shift_range=0.1,
height_shift_range=0.1,
horizontal_flip=True
)
datagen.fit(train_images.reshape(-1, 28, 28, 1))
✅ Ajustement des hyperparamètres
Expérimentez avec :
- Différentes fonctions d’activation (ReLU, Leaky ReLU, Tanh)
- Autres optimisateurs (SGD, RMSprop)
- Régularisation L2 ou Dropout pour éviter le surapprentissage
8. Sauvegarde et Déploiement du Modèle
Une fois satisfait du modèle, sauvegardons-le pour une utilisation future.
pythonCopierModifiermodel.save('fashion_mnist_model.h5')
Pour le recharger plus tard :
pythonCopierModifierloaded_model = keras.models.load_model('fashion_mnist_model.h5')
Ce modèle peut ensuite être déployé sur le web, un serveur ou un mobile avec TensorFlow Lite ou TensorFlow.js.
Conclusion 🎯
Nous avons vu comment entraîner un modèle de Deep Learning avec TensorFlow, en passant par :
✅ Le prétraitement des données
✅ La construction du modèle avec Keras
✅ L’entraînement et l’évaluation
✅ L’amélioration et le déploiement
Avec ces bases, vous êtes prêt à explorer des modèles plus complexes comme les réseaux convolutionnels (CNN), les réseaux récurrents (RNN) et les transformers pour des applications avancées en IA.
🚀 Envie d’aller plus loin ? Testez ces concepts sur vos propres projets et essayez des architectures plus avancées !
