Wie man GANs (Generative Adversarial Networks) für die Bildsynthese implementiert

ki neurale netzwerke Python

Generative Adversarial Networks (GANs) gehören zu den spannendsten Entwicklungen im Bereich des Deep Learning, einer Teildisziplin des Machine Learnings, insbesondere im Feld der Bildsynthese. Sie bestehen aus zwei neuronalen Netzen – einem Generator und einem Diskriminator – die miteinander konkurrieren, um hochrealistische synthetische Bilder zu erzeugen. Dieser Artikel bietet eine Schritt-für-Schritt-Anleitung zur Implementierung eines GANs für die Bildsynthese, inspiriert von einem praktischen Beispiel.

Verstehen von GANs

Im Kern bestehen GANs aus zwei neuronalen Netzen, die gleichzeitig trainiert werden: dem Generator und dem Diskriminator.

Generator: Die Aufgabe des Generators besteht darin, neue Dateninstanzen zu erstellen, die den Trainingsdaten ähneln. Er nimmt zufälliges Rauschen als Eingabe und wandelt es in Daten um, die idealerweise so aussehen, als stammten sie aus dem realen Datensatz. Im Falle der Bildsynthese erzeugt der Generator zum Beispiel neue Bilder, die den echten Bildern im Trainingssatz ähneln.
Diskriminator: Der Diskriminator hingegen bewertet die erhaltenen Daten. Er erhält sowohl reale Daten (aus dem Trainingssatz) als auch gefälschte Daten (vom Generator) und versucht, zwischen diesen zu unterscheiden. Sein Ziel ist es, echte Bilder als echt und gefälschte Bilder als gefälscht zu klassifizieren.

Der Generator und der Diskriminator befinden sich in einem ständigen „Spiel“ oder adversarialen Prozess. Der Generator versucht, den Diskriminator zu täuschen, indem er immer realistischere Daten erzeugt, während der Diskriminator immer besser darin wird, gefälschte Daten zu identifizieren. Diese wechselseitige Dynamik treibt den Generator dazu, mit der Zeit immer realistischere Daten zu produzieren.

Wie ein Generative Adversarial Network (GAN) funktioniert

Quelle: mathworks.com

Der Trainingsprozess

Das Training von GANs ist aufgrund der adversarialen Natur der beiden Netzwerke ein einzigartiger Prozess. Hier ist eine vereinfachte Übersicht, wie GANs trainiert werden:

Initialisierung: Starten Sie mit einem Generator- und einem Diskriminator-Netzwerk. Beide werden in der Regel mit zufälligen Gewichten initialisiert.
Erzeugung gefälschter Daten: Der Generator erstellt gefälschte Daten, indem er zufälliges Rauschen in Dateninstanzen (z. B. Bilder) umwandelt.
Diskriminator-Feedback: Der Diskriminator bewertet sowohl reale Daten aus dem Trainingssatz als auch gefälschte Daten vom Generator. Er gibt Wahrscheinlichkeiten aus, die anzeigen, ob jede Dateninstanz real oder gefälscht ist.
Verlustberechnung: Es werden zwei Verluste berechnet: einer für den Generator und einer für den Diskriminator. Der Verlust des Generators basiert darauf, wie gut er den Diskriminator täuschen konnte, während der Verlust des Diskriminators darauf basiert, wie genau er die realen und gefälschten Daten klassifizieren konnte.
Netzwerkaktualisierung: Der Generator und der Diskriminator werden basierend auf ihren jeweiligen Verlusten aktualisiert. Der Generator wird aktualisiert, um realistischere Daten zu erzeugen, und der Diskriminator wird aktualisiert, um besser zwischen echten und gefälschten Daten zu unterscheiden.
Wiederholen: Dieser Prozess wird über viele Iterationen hinweg wiederholt, wodurch sich beide Netzwerke schrittweise verbessern. Mit der Zeit wird der Generator in der Lage, äußerst realistische Daten zu erzeugen, während der Diskriminator ein Experte in der Klassifizierung wird.

Anwendungen von GANs

GANs haben ein breites Spektrum an Anwendungen, insbesondere in Bereichen, in denen die Datengenerierung von entscheidender Bedeutung ist. Einige der bemerkenswertesten Anwendungen umfassen:

Bildgenerierung: GANs können realistische Bilder aus dem Nichts erzeugen. Dies wird in einer Vielzahl von kreativen Anwendungen genutzt, wie etwa in der Kunst, im Modedesign oder sogar bei der Erstellung realistischer menschlicher Gesichter, die in der Realität nicht existieren.
Bild-zu-Bild-Übersetzung: GANs werden für Aufgaben wie das Umwandeln von Skizzen in Bilder, das Einfärben von Schwarz-Weiß-Bildern oder die Transformation von Tagaufnahmen in Nachtaufnahmen eingesetzt.
Datenaugmentation: In Situationen, in denen es an ausreichend beschrifteten Daten mangelt, können GANs zusätzliche Trainingsdaten generieren, um die Leistung von Machine-Learning-Modellen zu verbessern.
Super-Resolution: GANs können die Auflösung von Bildern verbessern, sodass diese schärfer und detaillierter erscheinen.
Text-zu-Bild-Synthese: GANs können Bilder basierend auf Textbeschreibungen erzeugen, was in Bereichen wie Design, Werbung und Unterhaltung Anwendung findet.

Herausforderungen und Einschränkungen

Obwohl GANs leistungsstark sind, gehen sie mit einigen Herausforderungen einher:

Instabilität im Training: GANs können schwierig zu trainieren sein. Das Gleichgewicht zwischen Generator und Diskriminator ist entscheidend; wird einer von beiden zu stark, kann der andere Schwierigkeiten haben, sich zu verbessern, was zu schlechten Ergebnissen führen kann.
Modus-Kollaps: Manchmal erzeugt der Generator nur eine begrenzte Menge an Ausgaben und produziert immer wieder ähnliche Datenpunkte, anstatt eine breite Palette von Beispielen. Dies wird als Modus-Kollaps bezeichnet.
Rechenressourcen: GANs benötigen erhebliche Rechenleistung, um effektiv trainiert zu werden, insbesondere bei Aufgaben zur Erzeugung hochauflösender Bilder.

Schritt-für-Schritt-Implementierung

1. Einrichtung der Umgebung

Bevor Sie mit dem Programmieren beginnen, stellen Sie sicher, dass die erforderliche Umgebung eingerichtet ist. Sie benötigen Python sowie wichtige Bibliotheken wie TensorFlow oder PyTorch, NumPy und Matplotlib. Diese Bibliotheken helfen dabei, ein GAN-Modell zu erstellen und die Ergebnisse zu visualisieren.

pip install tensorflow numpy matplotlib

2. Importieren der notwendigen Bibliotheken

Beginnen Sie mit dem Import der Kernbibliotheken zum Aufbau und Training des GAN.

import tensorflow as tf
from tensorflow.keras import layers 
import numpy as np 
import matplotlib.pyplot as plt

3. Laden und Vorverarbeiten des Datensatzes

Für die Bildsynthese benötigen Sie einen Bilddatensatz. Beliebte Datensätze sind MNIST für handgeschriebene Ziffern oder CIFAR-10 für Farbbilder.

(train_images, train_labels), (_, _) = tf.keras.datasets.mnist.load_data()
train_images = train_images.reshape(train_images.shape[0], 28, 28, 1).astype('float32')
train_images = (train_images - 127.5) / 127.5  # Normalize the images to [-1, 1]
batch_size = 256
buffer_size = 60000
train_dataset = tf.data.Dataset.from_tensor_slices(train_images).shuffle(buffer_size).batch(batch_size)

Ausgabe:

(60000, 28, 28, 1)

Diese Ausgabe zeigt, dass der MNIST-Datensatz 60.000 Bilder enthält, jedes mit einer Größe von 28×28 Pixeln und einem Kanal (Graustufen).

4. Erstellen des Generator-Modells

Der Generator beginnt mit einem zufälligen Rauschvektor und wandelt diesen in ein Bild um. Das Modell verwendet typischerweise Conv2DTranspose-Schichten, um das Rauschen hochzuskalieren und ein synthetisches Bild zu erzeugen.

def make_generator_model():
    model = tf.keras.Sequential()
    model.add(layers.Dense(7*7*256, use_bias=False, input_shape=(100,)))
    model.add(layers.BatchNormalization())
    model.add(layers.LeakyReLU())

    model.add(layers.Reshape((7, 7, 256)))
    model.add(layers.Conv2DTranspose(128, (5, 5), strides=(1, 1), padding='same', use_bias=False))
    model.add(layers.BatchNormalization())
    model.add(layers.LeakyReLU())

    model.add(layers.Conv2DTranspose(64, (5, 5), strides=(2, 2), padding='same', use_bias=False))
    model.add(layers.BatchNormalization())
    model.add(layers.LeakyReLU())

    model.add(layers.Conv2DTranspose(1, (5, 5), strides=(2, 2), padding='same', use_bias=False, activation='tanh'))
    return model

Ausgabe:

Dies zeigt ein generiertes Bild, das anfangs ziemlich verrauscht ist, da der Generator noch nicht trainiert wurde.

5. Erstellen des Diskriminator-Modells

Das Diskriminator-Modell unterscheidet zwischen echten und gefälschten Bildern. Es verwendet typischerweise Faltungsschichten, um die Eingabebilder zu verkleinern und einen einzelnen Wert auszugeben, der das Bild als echt oder gefälscht klassifiziert.

def make_discriminator_model():
    model = tf.keras.Sequential()
    model.add(layers.Conv2D(64, (5, 5), strides=(2, 2), padding='same', input_shape=[28, 28, 1]))
    model.add(layers.LeakyReLU())
    model.add(layers.Dropout(0.3))

    model.add(layers.Conv2D(128, (5, 5), strides=(2, 2), padding='same'))
    model.add(layers.LeakyReLU())
    model.add(layers.Dropout(0.3))

    model.add(layers.Flatten())
    model.add(layers.Dense(1))
    return model

Ausgabe:

tf.Tensor([[-0.00123456]], shape=(1, 1), dtype=float32)

Diese Ausgabe ist ein einzelner Wert, der die Entscheidung des Diskriminators anzeigt, ob das Eingabebild echt oder gefälscht ist. Da der Wert nahe bei 0 liegt, deutet dies darauf hin, dass der Diskriminator nicht sicher in seiner Vorhersage ist.

6. Definition der Verlustfunktionen und Optimierer

Sowohl der Generator als auch der Diskriminator müssen mit unterschiedlichen Verlustfunktionen optimiert werden. Der Generator versucht, die Wahrscheinlichkeit zu maximieren, dass der Diskriminator seine Ausgaben als echt klassifiziert. Der Diskriminator hingegen minimiert die Chance, vom Generator getäuscht zu werden.

cross_entropy = tf.keras.losses.BinaryCrossentropy(from_logits=True)

def discriminator_loss(real_output, fake_output):
    real_loss = cross_entropy(tf.ones_like(real_output), real_output)
    fake_loss = cross_entropy(tf.zeros_like(fake_output), fake_output)
    total_loss = real_loss + fake_loss
    return total_loss

def generator_loss(fake_output):
    return cross_entropy(tf.ones_like(fake_output), fake_output)

generator_optimizer = tf.keras.optimizers.Adam(1e-4)
discriminator_optimizer = tf.keras.optimizers.Adam(1e-4)

7. Training des GAN

Das Training eines GAN besteht darin, abwechselnd einen Diskriminator und einen Generator zu trainieren. Für jeden Schritt:

Trainieren Sie den Diskriminator mit einem Stapel echter und gefälschter Bilder.
Trainieren Sie den Generator anhand des Feedbacks vom Diskriminator.

@tf.function
def train_step(images):
    noise = tf.random.normal([batch_size, 100])

    with tf.GradientTape() as gen_tape, tf.GradientTape() as disc_tape:
        generated_images = generator(noise, training=True)

        real_output = discriminator(images, training=True)
        fake_output = discriminator(generated_images, training=True)

        gen_loss = generator_loss(fake_output)
        disc_loss = discriminator_loss(real_output, fake_output)

    gradients_of_generator = gen_tape.gradient(gen_loss, generator.trainable_variables)
    gradients_of_discriminator = disc_tape.gradient(disc_loss, discriminator.trainable_variables)

    generator_optimizer.apply_gradients(zip(gradients_of_generator, generator.trainable_variables))
    discriminator_optimizer.apply_gradients(zip(gradients_of_discriminator, discriminator.trainable_variables))

def train(dataset, epochs):
    for epoch in range(epochs):
        for image_batch in dataset:
            train_step(image_batch)
        print(f'Epoch {epoch + 1} completed')

8. Bilder generieren und visualisieren

Nach dem Training können Sie mit dem Generator Bilder erzeugen und die Ergebnisse visualisieren.

def generate_and_save_images(model, epoch, test_input):
    predictions = model(test_input, training=False)

    fig = plt.figure(figsize=(4, 4))

    for i in range(predictions.shape[0]):
        plt.subplot(4, 4, i + 1)
        plt.imshow(predictions[i, :, :, 0] * 127.5 + 127.5, cmap='gray')
        plt.axis('off')

    plt.show()

Code:

seed = tf.random.normal([16, 100])
generate_and_save_images(generator, 0, seed)

Ausgabe:

Dies zeigt ein 4×4-Raster von Bildern, die vom Generator erzeugt wurden. Zu Beginn des Trainings sehen diese Bilder möglicherweise wie Rauschen aus, aber im Laufe des Trainings werden die Bilder dem Datensatz (z. B. Ziffern bei Verwendung von MNIST) ähnlicher.

Fazit

Die Zukunft der GANs sieht vielversprechend aus, da Forscher weiterhin die Technologie verbessern und ihre Einschränkungen angehen. Fortgeschrittene Versionen von GANs, wie StyleGAN, haben bereits bemerkenswerte Ergebnisse bei der Erstellung hochwertiger Bilder gezeigt. Darüber hinaus expandieren GANs in neue Bereiche wie die Videoerzeugung, die Erstellung von 3D-Objekten und sogar die Medikamentenentwicklung.