Traitement des données d'images TensorFlow

Qu'est-ce que les données d'image

Les données d'image sont une matrice bidimensionnelle (image en niveaux de gris) ou un tenseur tridimensionnel (image en couleur) composé de pixels. Dans TensorFlow, les images sont généralement représentées comme suit :

  • Image en niveaux de gris : [hauteur, largeur] ou [hauteur, largeur, 1]
  • Image en couleur : [hauteur, largeur, 3] (canaux RVB)

Pourquoi le traitement d'image est nécessaire

  • Normalisation des données : unifier la taille et la plage de valeurs des images
  • Augmentation des données : augmenter la diversité des échantillons d'entraînement par des transformations
  • Extraction de caractéristiques : mettre en évidence les informations clés dans les images
  • Prétraitement : préparer le format de données approprié pour l'entrée du modèle

API principale de traitement d'images TensorFlow

Module tf.image

Une collection d'API spécifiquement dédiées au traitement d'images fournie par TensorFlow :

Exemple

import tensorflow as tf
from tensorflow import image as tf_image

Catégories de fonctions courantes :

Catégorie de fonctions Exemple des principales méthodes
Ajustement des couleurs adjust_brightness, adjust_contrast
Transformation géométrique flip, rotate, crop_to_bounding_box
Composition d'images blend, draw_bounding_boxes
Conversion de format encode_jpeg, decode_image
Opérations statistiques total_variation, per_image_standardization

Explication détaillée des techniques de prétraitement d'images

Traitement de normalisation

Normaliser les valeurs de pixels sur une plage fixe (généralement [0,1] ou [-1,1]):

Exemple

def normalize(image):
    """Normaliser l'image uint8 sur la plage [0,1]"""
    image = tf.cast(image, tf.float32)  # Convertir en float32
    return image / 255.0  # Diviser par la valeur maximale

# Exemple d'utilisation
image = tf.random.uniform([256,256,3], 0, 255, dtype=tf.uint8)
normalized_image = normalize(image)

Techniques d'augmentation des données

Augmenter la diversité des données grâce à des transformations aléatoires :

Exemple

def augment_image(image, label):
    """Pipeline de traitement d'images appliquant une augmentation aléatoire"""
    # Retournement aléatoire gauche-droite
    image = tf_image.random_flip_left_right(image)
   
    # Ajustement aléatoire de la luminosité
    image = tf_image.random_brightness(image, max_delta=0.2)
   
    # Ajustement aléatoire du contraste
    image = tf_image.random_contrast(image, lower=0.8, upper=1.2)
   
    # Rotation aléatoire (-15° à +15°)
    angle = tf.random.uniform([], -15, 15) * (3.1415/180)
    image = tf_image.rotate(image, angle)
   
    return image, label

Processus de chargement et de traitement par lots d'images

Pipeline de traitement complet

Implémentation réelle du code

Exemple

def preprocess_dataset(dataset, batch_size=32, is_training=False):
    """Construire le pipeline de prétraitement d'images"""
   
    # Définir la fonction de prétraitement
    def _preprocess(image, label):
        # Décoder l'image JPEG
        image = tf_image.decode_jpeg(image, channels=3)
        # Redimensionner à une taille uniforme
        image = tf_image.resize(image, [224, 224])
        # Appliquer l'augmentation de données pendant l'entraînement
        if is_training:
            image = augment_image(image)
        # Traitement de normalisation
        image = normalize(image)
        return image, label
   
    # Appliquer le prétraitement et créer des lots
    dataset = dataset.map(_preprocess, num_parallel_calls=tf.data.AUTOTUNE)
    dataset = dataset.batch(batch_size)
    dataset = dataset.prefetch(tf.data.AUTOTUNE)
   
    return dataset

Techniques avancées de traitement d'images

Utilisation des couches de prétraitement Keras

TensorFlow 2.x fournit des API de prétraitement plus avancées :

Exemple

from tensorflow.keras.layers.experimental import preprocessing

# Créer un modèle de prétraitement
augmenter = tf.keras.Sequential([
    preprocessing.RandomFlip("horizontal"),
    preprocessing.RandomRotation(0.1),
    preprocessing.RandomZoom(0.1),
    preprocessing.Rescaling(1./255)  # Normalisation
])

# Utilisation dans le modèle
model = tf.keras.Sequential([
    augmenter,  # Couches d'augmentation de données
    tf.keras.layers.Conv2D(32, 3, activation='relu'),
    # Autres couches...
])

Couches de traitement d'image personnalisées

Implémentez des opérations de prétraitement personnalisées :

Exemple

class RandomColorDistortion(tf.keras.layers.Layer):
    def __init__(self, contrast_range=[0.5, 1.5], **kwargs):
        super().__init__(**kwargs)
        self.contrast_range = contrast_range
       
    def call(self, images, training=None):
        if not training:
            return images
           
        # Ajustement aléatoire du contraste
        contrast_factor = tf.random.uniform(
            [], self.contrast_range[0], self.contrast_range[1])
        images = tf.image.adjust_contrast(images, contrast_factor)
       
        # Ajustement aléatoire de la saturation
        images = tf.image.random_saturation(images, 0.5, 1.5)
       
        return images

Exercices pratiques

Exercice 1 : Comparaison de normalisation d'images

Chargez une image de test, appliquez respectivement les méthodes de normalisation suivantes, et visualisez les résultats :

  1. Diviser par 255 (plage [0,1])
  2. Normalisation par moyenne-écart-type ImageNet (mean=[0.485,0.456,0.406], std=[0.229,0.224,0.225])
  3. Normalisation personnalisée (par ex., mise à l'échelle vers la plage [-1,1])

Exercice 2 : Observation des effets de l'augmentation de données

Sélectionner une image, appliquer différentes combinaisons de techniques d'augmentation (retournement + rotation + ajustement des couleurs), générer 10 versions augmentées et les afficher dans un tableau pour observer les effets de l'augmentation.

Exercice 3 : Pipeline complet de prétraitement

Construire un pipeline complet de prétraitement d'images, comprenant les étapes suivantes :

  1. Charger les images depuis TFRecord
  2. Décoder les images
  3. Recadrage aléatoire en 256x256
  4. Retournement horizontal aléatoire
  5. Normaliser vers la plage [-1,1]
  6. Créer un jeu de données avec une taille de lot de 32

Questions fréquentes

Q1 : Comment gérer des images de tailles différentes ?

R : Utiliseztf.image.resizepour unifier les tailles, ou utilisertf.image.resize_with_crop_or_padpour recadrer/ajouter du remplissage tout en conservant le rapport d'aspect.

Q2 : Le traitement d'image doit-il être effectué sur CPU ou GPU ?

R : Il est généralement recommandé d'effectuer le prétraitement d'image sur le CPU, en utilisanttf.data.Dataset.mapdenum_parallel_callsle paramètre pour le traitement parallèle.

Q3 : Comment éviter la perte d'information causée par l'augmentation de données ?

R : Définissez raisonnablement les plages de paramètres d'augmentation. Pour les tâches critiques (comme les images médicales), utilisez les transformations géométriques avec prudence et privilégiez les transformations d'espace colorimétrique.

Q4 : Meilleures pratiques pour le traitement d'images très grandes ?

R : Envisagez d'utilisertf.image.extract_patchespour diviser les grandes images en petits patchs, ou utiliser des techniques de chargement progressif.

Autres extensions