Crée un model de classification d’image de chat et de chien avec python et tensorflow

Créer un modèle de classification d’images de chats et de chiens est un excellent projet pour mettre en action vos compétences en apprentissage automatique et les réseaux de convolution. Voici un tutoriel détaillé étape par étape pour vous guider à travers ce processus. On utilisera Python et TensorFlow pour crée et tester le model:

Prérequis :

• Python installé sur votre système.
• Les bibliothèques Python suivantes : TensorFlow, NumPy, Matplotlib (pour la visualisation).

Étape 1 : Préparation des données

1. Téléchargez l’ensemble de données de chats et de chiens. Vous pouvez utiliser l’ensemble de données « Dogs vs. Cats » de Kaggle : Lien vers l’ensemble de données.
2. Divisez les images en un ensemble d’entraînement et un ensemble de test. Organisez les images de chats et de chiens dans des dossiers distincts pour chaque ensemble.
3. Assurez-vous que les images ont des dimensions cohérentes. Vous pouvez redimensionner toutes les images à une taille spécifique, par exemple 150×150 pixels.

Étape 2 : Installation de TensorFlow

Installez TensorFlow en utilisant pip :

pip install tensorflow

Étape 3 : Création du modèle de classification

Le modèle est construit en utilisant TensorFlow et Keras, qui est une API de haut niveau pour construire des réseaux neuronaux.

import tensorflow as tf
from tensorflow.keras.models import Sequential
from tensorflow.keras.layers import Conv2D, MaxPooling2D, Flatten, Dense, Dropout
from tensorflow.keras.preprocessing.image import ImageDataGenerator

Dans cette section, nous importons les bibliothèques nécessaires, y compris TensorFlow et ses composants Keras pour la création de modèles.

model = Sequential() 

Nous créons un modèle séquentiel. Un modèle séquentiel est une pile linéaire de couches.

model.add(Conv2D(32, (3, 3), activation='relu', input_shape=(150, 150, 3)))
model.add(MaxPooling2D(2, 2))

model.add(Conv2D(64, (3, 3), activation='relu'))
model.add(MaxPooling2D(2, 2))

model.add(Conv2D(128, (3, 3), activation='relu'))
model.add(MaxPooling2D(2, 2))

model.add(Conv2D(128, (3, 3), activation='relu'))
model.add(MaxPooling2D(2, 2))

Nous ajoutons des couches convolutionnelles et de max-pooling pour extraire des caractéristiques de l’image. Le modèle commence par une couche de convolution avec 32 filtres de taille (3, 3) et une fonction d’activation ReLU. L’argument input_shape spécifie que les images en entrée ont une taille de 150×150 pixels avec 3 canaux de couleur (RGB). Ensuite, nous ajoutons plusieurs couches similaires pour augmenter la complexité du modèle.

model.add(Flatten())

La couche Flatten convertit la sortie des couches convolutionnelles en un vecteur unidimensionnel pour pouvoir être connectée à des couches entièrement connectées (dense).

model.add(Dense(512, activation='relu'))
model.add(Dropout(0.5))

model.add(Dense(1, activation='sigmoid'))

Nous ajoutons deux couches entièrement connectées (dense). La première couche a 512 neurones et utilise la fonction d’activation ReLU. La couche Dropout est utilisée pour régulariser le modèle et éviter la surajustement (overfitting). Enfin, la couche de sortie a un seul neurone avec une fonction d’activation sigmoid, ce qui convient à la classification binaire (chat ou chien).

model.compile(optimizer='adam', loss='binary_crossentropy', metrics=['accuracy'])

Nous compilons le modèle en spécifiant l’optimiseur (« adam » est un optimiseur couramment utilisé), la fonction de perte (binary_crossentropy pour une classification binaire) et les métriques que nous voulons surveiller pendant l’entraînement (précision ici).

Étape 4 : Prétraitement des données

Utilisez la classe ImageDataGenerator de TensorFlow pour prétraiter les images. Elle effectue des augmentations de données telles que la rotation, le retournement, le zoom, etc.

train_datagen = ImageDataGenerator( 
  rescale=1.0/255, 
  rotation_range=40, 
  width_shift_range=0.2, 
  height_shift_range=0.2, 
  shear_range=0.2, zoom_range=0.2, 
  horizontal_flip=True, 
  fill_mode='nearest' ) 
test_datagen = ImageDataGenerator(rescale=1.0/255) 
train_generator = train_datagen.flow_from_directory( 'train', target_size=(150, 150), batch_size=32, class_mode='binary' ) 
validation_generator = test_datagen.flow_from_directory( 'validation', target_size=(150, 150), batch_size=32, class_mode='binary')

Étape 5 : Entraînement du modèle

Le modèle est maintenant prêt à être entraîné.

history = model.fit(
    train_generator,
    steps_per_epoch=100,  # Nombre d'échantillons d'entraînement par époque
    epochs=20,  # Nombre d'époques d'entraînement
    validation_data=validation_generator,
    validation_steps=50  # Nombre d'échantillons de validation par époque
)

Nous utilisons la méthode fit pour entraîner le modèle. Nous spécifions l’ensemble d’entraînement (train_generator) et l’ensemble de validation (validation_generator) ainsi que d’autres paramètres comme le nombre d’époques.

Étape 6 : Visualisation des résultats

Utilisez Matplotlib pour visualiser les résultats de l’entraînement, tels que les courbes d’apprentissage et les performances du modèle.

import matplotlib.pyplot as plt

# Courbes d'apprentissage
acc = history.history['accuracy']
val_acc = history.history['val_accuracy']
loss = history.history['loss']
val_loss = history.history['val_loss']

epochs = range(1, len(acc) + 1)

plt.figure(figsize=(12, 5))

plt.subplot(1, 2, 1)
plt.plot(epochs, acc, 'bo', label='Entraînement')
plt.plot(epochs, val_acc, 'b', label='Validation')
plt.title('Précision d\'entraînement et de validation')
plt.xlabel('Époques')
plt.ylabel('Précision')
plt.legend()

plt.subplot(1, 2, 2)
plt.plot(epochs, loss, 'bo', label='Entraînement')
plt.plot(epochs, val_loss, 'b', label='Validation')
plt.title('Perte d\'entraînement et de validation')
plt.xlabel('Époques')
plt.ylabel('Perte')
plt.legend()

plt.show()

Étape 7 : Évaluation du modèle

Évaluez le modèle sur l’ensemble de test pour obtenir la performance finale.

test_loss, test_acc = model.evaluate(validation_generator)
print(f'Précision sur l\'ensemble de test : {test_acc * 100:.2f}%')

Étape 8 : Utilisation du modèle

Utilisez le modèle pour prédire si une nouvelle image correspond a c’elle d’un chat ou d’un chien.

# Chargez une image de test
img_path = 'test/cat_or_dog.jpg'
img = tf.keras.utils.load_img(img_path, target_size=(150, 150))

# Prétraitez l'image
img_array = tf.keras.utils.img_to_array(img)
img_array = np.expand_dims(img_array, axis=0)
img_array /= 255.0  # Normalisation

# Prédiction
prediction = model.predict(img_array)

if prediction[0] > 0.5:
    print('C\'est un chien !')
else:
    print('C\'est un chat !')

C’est tout ! Vous avez créé un modèle de classification d’images de chats et de chiens avec Python et TensorFlow. N’hésitez pas à ajuster les hyperparamètres, à explorer d’autres architectures de modèles ou à utiliser des modèles pré-entraînés pour améliorer les performances de votre modèle.