TensorFlow Bilddatenverarbeitung

Was sind Bilddaten

Bilddaten sind eine zweidimensionale Matrix (Graustufenbild) oder ein dreidimensionaler Tensor (Farbbild), zusammengesetzt aus Pixeln. In TensorFlow werden Bilder typischerweise wie folgt dargestellt:

  • Graustufenbild: [height, width] oder [height, width, 1]
  • Farbbild: [height, width, 3] (RGB-Kanäle)

Warum ist Bildverarbeitung erforderlich

  • Datennormalisierung: Bildgröße und Wertebereich vereinheitlichen
  • Datenaugmentierung: Vielfalt der Trainingsbeispiele durch Transformationen erhöhen
  • Merkmalsextraktion: wichtige Informationen in Bildern hervorheben
  • Vorverarbeitung: geeignetes Datenformat für die Modelleingabe vorbereiten

TensorFlow-Bildverarbeitungs-Kern-API

tf.image-Modul

Eine Sammlung von APIs, die TensorFlow speziell für die Bildverarbeitung bereitstellt:

Beispiel

import tensorflow as tf
from tensorflow import image as tf_image

Gängige Funktionskategorien:

Funktionskategorie Beispiel für Hauptmethoden
Farbanpassung adjust_brightness, adjust_contrast
Geometrische Transformation flip, rotate, crop_to_bounding_box
Bildkomposition blend, draw_bounding_boxes
Formatkonvertierung encode_jpeg, decode_image
Statistische Operationen total_variation, per_image_standardization

Detaillierte Erläuterung der Techniken zur Bildvorverarbeitung

Normalisierungsverarbeitung

Pixelwerte auf einen festen Bereich normalisieren (üblicherweise [0,1] oder [-1,1]):

Beispiel

def normalize(image):
    """uint8-Bild auf den Bereich [0,1] normalisieren"""
    image = tf.cast(image, tf.float32)  # In float32 konvertieren
    return image / 255.0  # Durch den Maximalwert teilen

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

Techniken zur Daten-Augmentierung

Erhöhen Sie die Datenvielfalt durch zufällige Transformationen:

Beispiel

def augment_image(image, label):
    """Bildverarbeitungs-Pipeline, die zufällige Augmentierung anwendet"""
    # Zufällige Links-Rechts-Spiegelung
    image = tf_image.random_flip_left_right(image)
   
    # Zufällige Helligkeitsanpassung
    image = tf_image.random_brightness(image, max_delta=0.2)
   
    # Zufällige Kontrastanpassung
    image = tf_image.random_contrast(image, lower=0.8, upper=1.2)
   
    # Zufällige Rotation (-15° bis +15°)
    angle = tf.random.uniform([], -15, 15) * (3.1415/180)
    image = tf_image.rotate(image, angle)
   
    return image, label

Bildlade- und Batchverarbeitungsprozess

Vollständige Verarbeitungspipeline

Tatsächliche Code-Implementierung

Beispiel

def preprocess_dataset(dataset, batch_size=32, is_training=False):
    """Bildvorverarbeitungspipeline erstellen"""
   
    # Vorverarbeitungsfunktion definieren
    def _preprocess(image, label):
        # JPEG-Bild dekodieren
        image = tf_image.decode_jpeg(image, channels=3)
        # Auf Größe skalieren
        image = tf_image.resize(image, [224, 224])
        # Daten-Augmentierung während des Trainings anwenden
        if is_training:
            image = augment_image(image)
        # Normalisierungsverarbeitung
        image = normalize⟦⟧image(image)
        return image, label
   
    # Vorverarbeitung anwenden und Batches erstellen
    dataset = dataset.map(_preprocess, num_parallel_calls=tf.data.AUTOTUNE)
    dataset = dataset.batch(batch_size)
    dataset = dataset.prefetch(tf.data.AUTOTUNE)
   
    return dataset

Fortgeschrittene Techniken der Bildverarbeitung

Verwendung von Keras Preprocessing Layers

TensorFlow 2.x bietet fortgeschrittenere Vorverarbeitungs-APIs:

Beispiel

from tensorflow.keras.layers.experimental import preprocessing

# Vorverarbeitungsmodell erstellen
augmenter = tf.keras.Sequential([
    preprocessing.RandomFlip("horizontal"),
    preprocessing.RandomRotation(0.1),
    preprocessing.RandomZoom(0.1),
    preprocessing.Rescaling(1./255)  # Normalisierung
])

# Im Modell verwenden
model = tf.keras.Sequential([
    augmenter,  # Datenaugmentierungsschichten
    tf.keras.layers.Conv2D(32, 3, activation='relu'),
    # Weitere Layer...
])

Benutzerdefinierte Layer zur Bildverarbeitung

Implementiere benutzerdefinierte Vorverarbeitungsoperationen:

Beispiel

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
           
        # Zufällige Kontrastanpassung
        contrast_factor = tf.random.uniform(
            [], self.contrast_range[0], self.contrast_range[1])
        images = tf.image.adjust_contrast(images, contrast_factor)
       
        # Zufällige Sättigungsanpassung
        images = tf.image.random_saturation(images, 0.5, 1.5)
       
        return images

Praktische Übungen

Übung 1: Vergleich der Bildnormalisierung

Lade ein Testbild, wende die folgenden Normalisierungsmethoden jeweils an und visualisiere die Ergebnisse:

  1. Durch 255 teilen ([0,1]-Bereich)
  2. ImageNet-Normalisierung mit Mittelwert und Standardabweichung (mean=[0.485,0.456,0.406], std=[0.229,0.224,0.225])
  3. Benutzerdefinierte Normalisierung (z. B. Skalierung auf den Bereich [-1,1])

Übung 2: Auswirkungen von Data Augmentation beobachten

Wählen Sie ein Bild aus, wenden Sie verschiedene Kombinationen von Augmentierungstechniken an (Spiegelung + Rotation + Farbanpassung), generieren Sie 10 augmentierte Versionen und zeigen Sie sie in einem Array an, um die Auswirkungen der Augmentierung zu beobachten.

Übung 3: Vollständige Vorverarbeitungs-Pipeline

Erstellen Sie eine vollständige Bildvorverarbeitungs-Pipeline, einschließlich der folgenden Schritte:

  1. Bilder aus TFRecord laden
  2. Bilder dekodieren
  3. Zufälliger Zuschnitt auf 256x256
  4. Zufällige horizontale Spiegelung
  5. Auf den Bereich [-1,1] normalisieren
  6. Erstellen Sie einen Datensatz mit Batch-Größe 32

Häufig gestellte Fragen

F1: Wie geht man mit Bildern unterschiedlicher Größe um?

A: Verwenden Sietf.image.resizeum Größen zu vereinheitlichen, oder verwenden Sietf.image.resize_with_crop_or_padzum Zuschneiden/Auffüllen unter Beibehaltung des Seitenverhältnisses.

F2: Sollte die Bildverarbeitung auf CPU oder GPU erfolgen?

A: Es wird normalerweise empfohlen, die Bildvorverarbeitung auf der CPU durchzuführen, unter Verwendung destf.data.Dataset.mapvonnum_parallel_callsParameters für die parallele Verarbeitung.

F3: Wie vermeidet man Informationsverlust, der durch Datenaugmentierung verursacht wird?

A: Legen Sie die Bereiche der Augmentierungsparameter angemessen fest. Bei kritischen Aufgaben (wie medizinischen Bildern) verwenden Sie geometrische Transformationen mit Vorsicht und priorisieren Sie Farbraumtransformationen.

F4: Best Practices für die Verarbeitung sehr großer Bilder?

A: Erwägen Sie die Verwendung vontf.image.extract_patchesum große Bilder in kleine Patches aufzuteilen, oder verwenden Sie Techniken zum progressiven Laden.

Andere Erweiterungen