Segmentation d’Images

Fonctions :

• Segmentation d’Images (exemple)

  La segmentation d’images consiste à attribuer une étiquette à chaque pixel d’une image, afin de délimiter précisément les objets ou zones d’intérêt. Elle est utilisée dans la vision par ordinateur pour identifier des régions spécifiques comme des objets, personnes, routes, etc. La segmentation s’appuie souvent sur des architectures de réseaux de neurones convolutifs (CNN) spécialisées comme U-Net, qui apprennent à segmenter finement les images en classes multiples, pixel par pixel.

  Exemple de code :

  📋 Copy

  import tensorflow as tf
  import tensorflow_datasets as tfds
  import matplotlib.pyplot as plt
  
  # Paramètres
  IMG_SIZE = 128
  BATCH_SIZE = 128
  EPOCHS = 1
  NUM_CLASSES = 3  # oxford_iiit_pet a 3 classes dans les masques (fond, bord, objet)
  
  # Charger le dataset avec annotations de segmentation
  dataset, info = tfds.load('oxford_iiit_pet:4.0.0', with_info=True)
  
  # train_ds et test_ds sont des tuples (image, segmentation_mask)
  train_ds = dataset['train']
  test_ds = dataset['test']
  
  def normalize(datapoint):
      input_image = datapoint['image']
      input_mask = datapoint['segmentation_mask']
  
      input_image = tf.image.resize(input_image, (IMG_SIZE, IMG_SIZE))
      input_image = input_image / 255.0
  
      input_mask = tf.image.resize(input_mask, (IMG_SIZE, IMG_SIZE), method='nearest')
      input_mask = tf.cast(input_mask, tf.int32) - 1
  
      return input_image, input_mask
  
  # Préparer les datasets
  train = train_ds.map(normalize).cache().shuffle(1000).batch(BATCH_SIZE).prefetch(tf.data.AUTOTUNE)
  test = test_ds.map(normalize).batch(BATCH_SIZE).prefetch(tf.data.AUTOTUNE)
  
  # U-Net simple
  def unet_model(output_channels):
      inputs = tf.keras.layers.Input(shape=[IMG_SIZE, IMG_SIZE, 3])
  
      # Encoder
      c1 = tf.keras.layers.Conv2D(64, 3, activation='relu', padding='same')(inputs)
      p1 = tf.keras.layers.MaxPooling2D()(c1)
  
      c2 = tf.keras.layers.Conv2D(128, 3, activation='relu', padding='same')(p1)
      p2 = tf.keras.layers.MaxPooling2D()(c2)
  
      # Bottleneck
      b = tf.keras.layers.Conv2D(256, 3, activation='relu', padding='same')(p2)
  
      # Decoder
      u1 = tf.keras.layers.UpSampling2D()(b)
      c3 = tf.keras.layers.Conv2D(128, 3, activation='relu', padding='same')(u1)
  
      u2 = tf.keras.layers.UpSampling2D()(c3)
      c4 = tf.keras.layers.Conv2D(64, 3, activation='relu', padding='same')(u2)
  
      outputs = tf.keras.layers.Conv2D(output_channels, 1, activation='softmax')(c4)
  
      return tf.keras.Model(inputs=inputs, outputs=outputs)
  
  model = unet_model(NUM_CLASSES)
  model.compile(optimizer='adam',
                loss='sparse_categorical_crossentropy',
                metrics=['accuracy'])
  
  # Entraînement
  model.fit(train, epochs=EPOCHS)
  
  # Fonction d'affichage
  def display(display_list):
      plt.figure(figsize=(15, 5))
      title = ['Image', 'Masque vrai', 'Masque prédit']
  
      for i in range(len(display_list)):
          plt.subplot(1, len(display_list), i + 1)
          plt.title(title[i])
          if i == 0:
              plt.imshow(display_list[i])
          else:
              # Affiche masque en couleurs avec palette
              plt.imshow(tf.keras.preprocessing.image.array_to_img(display_list[i]), cmap='gray', vmin=0, vmax=NUM_CLASSES-1)
          plt.axis('off')
      plt.show()
  
  # Test sur quelques images
  for image, mask in test.take(3):
      pred_mask = model.predict(image)
      pred_mask = tf.argmax(pred_mask, axis=-1)
      pred_mask = tf.expand_dims(pred_mask, axis=-1)
      for i in range(image.shape[0]):
          display([image[i], mask[i], pred_mask[i]])

  Explication du code :

  1. Définition des paramètres
   
  - Taille des images redimensionnées : 128x128 pixels. 
  - Taille des batchs : 128. 
  - Nombre d’époques d’entraînement : 1. 
  - Nombre de classes dans les masques : 3 (fond, bord, objet). 
  
  2. Chargement du dataset Oxford-IIIT Pet
   
  - Chargement via `tensorflow_datasets` avec les images et les masques de segmentation. 
  - Séparation en datasets d’entraînement et de test. 
  
  3. Normalisation et préparation des données
   
  - Fonction `normalize` : 
  - Redimensionnement des images à 128x128 pixels et normalisation des pixels entre 0 et 1. 
  - Redimensionnement des masques avec interpolation « nearest » pour préserver les labels. 
  - Conversion des masques en entiers et décalage des labels de 1 à 0 (fond), 1 (bord), 2 (objet). 
  
  4. Construction des pipelines de données
   
  - Application de la normalisation sur train et test. 
  - Entraînement : cache, mélange aléatoire, batchs de 32, préchargement asynchrone. 
  - Test : cache, batchs de 32, préchargement asynchrone. 
  
  5. Définition du modèle U-Net simplifié
   
  - Entrée : images 128x128x3. 
  - Encoder : deux blocs convolution + max pooling (64 puis 128 filtres). 
  - Bottleneck : convolution avec 256 filtres. 
  - Decoder : deux blocs upsampling + convolution (128 puis 64 filtres). 
  - Sortie : convolution 1x1 avec activation softmax sur 3 classes. 
  
  6. Compilation et entraînement du modèle
   
  - Optimiseur Adam, fonction perte `sparse_categorical_crossentropy`. 
  - Métrique : accuracy. 
  - Entraînement sur 1 époques. 
  
  7. Fonction d’affichage des résultats
   
  - Affichage côte à côte : image d’entrée, masque vrai, masque prédit. 
  - Masques affichés en niveaux de gris avec palette adaptée aux 3 classes. 
  
  8. Test et visualisation
   
  - Prédiction sur 3 batchs du dataset test. 
  - Application d’un argmax sur les prédictions pour obtenir la classe la plus probable. 
  - Affichage individuel des images, masques vrais et masques prédits pour chaque image.