Revolutionierung der kreativen Skizzenerstellung mit DCGAN

Einführung

Der Bereich der künstlichen Intelligenz hat ein erhebliches Wachstum und eine Ausweitung auf kreative Bereiche wie Skizzieren und Kritzeln erlebt. Beim Skizzieren haben sich herkömmliche KI-Ansätze hauptsächlich auf das Imitieren gewöhnlicher und realer Skizzen konzentriert. Dennoch bieten die jüngsten Entwicklungen bei Generative Adversarial Networks (GANs) eine revolutionary Perspektive für die kreative Skizzenerstellung. Die Studie untersucht die Particulars der Implementierung von DCGAN zusammen mit dem Fast, Draw!-Datensatz: seine Techniken und wie es die menschliche Kreativität beeinflussen kann, indem es als Inspiration für andere dient, die an ihren kreativen Projekten beteiligt sind.

Überblick

• Das Dokument hebt die Fortschritte der KI im Skizzieren hervor und konzentriert sich auf die revolutionary Rolle von GANs bei der Erstellung kreativer Skizzen.
• Es erläutert die Architektur von DCGAN und betont die Rolle des Mills und Diskriminators bei der Erzeugung qualitativ hochwertiger Bilder.
• Die Studie demonstriert die Implementierung von DCGAN mit dem Fast, Draw!-Datensatz und dessen Einfluss auf die Steigerung der menschlichen Kreativität.
• Leistungsmetriken wie FID und CS werden besprochen, um die Fähigkeit von DCGAN zu bewerten, vielfältige und erkennbare Skizzen zu erstellen.
• Es werden die Möglichkeiten von DCGAN in interaktiven Skizzierwerkzeugen untersucht, die Künstler unterstützen und die Zusammenarbeit zwischen Mensch und Maschine fördern.

Was ist kreatives Skizzieren?

Skizzieren ist seit prähistorischen Zeiten eine wichtige Kind der visuellen Kommunikation und ist heute ein beliebtes kreatives Werkzeug. Die Einführung von Touchscreen-Geräten hat ihren Anwendungsbereich noch erweitert. Die Rolle der Intelligenz in diesem Bereich besteht nur darin, wahre Kunst zu verstehen und zu schaffen. Kreative Kunst beinhaltet jedoch einzigartige Charaktere und emotionale Reaktionen und präsentiert komplexere Themen. Hier glänzt DCGAN.

DCGAN verstehen

DCGAN oder Deep Convolutional Generative Adversarial Community ist ein GAN speziell für die Erstellung hochwertiger Bilder entwickelt. Es arbeitet mit zwei Hauptfaktoren: Generator und Diskriminierung

Das Bild zeigt die Architektur eines Deep Convolutional Generative Adversarial Community (DCGAN). Es zeigt die Struktur der Generator- und Diskriminatornetzwerke und hebt die Schichten und Operationen hervor, die an der Generierung und Unterscheidung von Bildern beteiligt sind.

Generatorarchitektur

Der Generator wandelt einen niedrigdimensionalen Zufallsrauschvektor in ein hochdimensionales Bild um. Der Prozess umfasst Upsampling und Faltungsschichten mit ReLU-Aktivierungsfunktionen.

• Eingabeebene:
  • Die Eingabe für den Generator ist ein zufälliger Rauschvektor, normalerweise der Größe 100.
• Dichte Schicht:
  • Der Rauschvektor wird durch eine dichte (vollständig verbundene) Schicht geleitet, um seine Dimensionalität zu erweitern, was zu einem Tensor der Kind 512 × 4 × 4 führt.
• Upsampling und Convolutional-Schichten:
  • Der Generator verwendet eine Reihe von Upsampling-Ebenen (häufig implementiert als transponierte Faltung oder Dekonvolution), um die räumlichen Dimensionen des Tensors zu erhöhen.
  • Auf jeden Upsampling-Schritt folgt eine Faltungsschicht mit ReLU-Aktivierung und Batch-Normalisierung, um die Funktionen zu verfeinern.
  • Bei jedem Schritt verdoppeln sich die räumlichen Dimensionen, während die Anzahl der Merkmalskarten abnimmt.
  • Die Schichten werden wie folgt erweitert:
    • 512×4×4
    • 256×8×8
    • 128×16×16
    • 64×32×32
    • 32×64×64
    • 2×128×128

Diskriminator-Architektur

Der Diskriminator zielt darauf ab, zwischen echten und gefälschten Bildern zu unterscheiden, indem er die Eingabebilder herunterskaliert und Faltungsschichten mit Leaky-ReLU-Aktivierungen anwendet.

• Eingabeebene:
  • Die Eingabe für den Diskriminator ist ein Bild, normalerweise in der Größe 128×128×2.
• Faltungsschichten:
  • Der Diskriminator verwendet eine Reihe von Faltungsschichten, um die räumlichen Dimensionen des Eingabebildes zu reduzieren und gleichzeitig die Tiefe der Merkmalskarten zu erhöhen.
  • Auf jeden Faltungsschritt folgen eine Leaky-ReLU-Aktivierungsfunktion und ein Dropout zur Regularisierung.
  • Bei jedem Schritt halbieren sich die räumlichen Dimensionen, während die Anzahl der Characteristic-Maps zunimmt.
  • Die Schichten werden wie folgt reduziert:
    • 2×128×128
    • 32×64×64
    • 64×32×32
    • 128×16×16
    • 256×8×8
    • 512×4×4
• Dichte Schicht und Ausgabe:
  • Der endgültige Tensor wird abgeflacht und durch eine dichte Schicht geleitet, um einen einzelnen Wert zu erzeugen.
  • Die Ausgabe ist eine Wahrscheinlichkeit, wobei 0 ein gefälschtes Bild und 1 ein echtes Bild anzeigt.

Schlüsselkomponenten

• Upsampling + ReLU (Generator):
  • Die linken Abschnitte im Generator stellen Upsampling-Operationen dar, gefolgt von ReLU-Aktivierungen, die die räumlichen Dimensionen erweitern und die Bildauflösung erhöhen.
• Faltung + Leaky ReLU (Diskriminator):
  • Die rechten Abschnitte im Diskriminator stellen Faltungsoperationen dar, gefolgt von Leaky-ReLU-Aktivierungen, die das Bild herunterskalieren und Merkmale extrahieren, um die Authentizität zu bestimmen.

Coaching und Inferenz mit Fast, Draw!-Daten

Um die Fähigkeiten von DCGAN zu demonstrieren, haben wir den Fast, Draw!-Datensatz verwendet, der Millionen von Kritzeleien in verschiedenen Kategorien enthält. In diesem Beispiel haben wir uns auf die Kategorie „Blume“ konzentriert.

Laden der Fast, Draw!-Daten

Zuerst haben wir den Fast, Draw!-Blumendatensatz geladen und vorverarbeitet:

import numpy as np
import requests
from io import BytesIO

# Load Fast, Draw! Information
quickdraw_url="https://storage.googleapis.com/quickdraw_dataset/full/numpy_bitmap/flower.npy"
response = requests.get(quickdraw_url)
information = np.load(BytesIO(response.content material))
information = (information.astype(np.float32) / 127.5) - 1.0  # Normalize to (-1, 1)
information = information.reshape(-1, 28, 28, 1)

Dieser Code lädt den Fast, Draw!-Datensatz herunter, normalisiert die Pixelwerte auf den Bereich (-1, 1) und formt sie für die Verwendung im Modell neu.

Definition der DCGAN-Architektur

Als Nächstes haben wir die DCGAN-Architektur definiert, einschließlich der Generator- und Diskriminatormodelle:

Initialisierung der DCGAN-Klasse

class DCGAN():
    def __init__(self):
        self.img_shape = (28, 28, 1)
        self.latent_dim = 100
        self.optimizer = tf.keras.optimizers.legacy.Adam(0.0002, 0.5)

        # Construct and compile the discriminator
        self.discriminator = self.build_discriminator()
        self.discriminator.compile(loss="binary_crossentropy", optimizer=self.optimizer)

        # Construct and compile the generator
        self.generator = self.build_generator()
        self.generator.compile(loss="binary_crossentropy", optimizer=self.optimizer)

        # Construct the mixed mannequin
        self.gan = self.build_GAN()

Dadurch wird die DCGAN-Klasse initialisiert und die Bildform, die latente Dimension und der Optimierer definiert. Außerdem werden die Generator- und Diskriminatormodelle erstellt und kompiliert.

Aufbau des GAN

def build_GAN(self):
    self.discriminator.trainable = False
    gan_input = Enter(form=(self.latent_dim,))
    img = self.generator(gan_input)
    gan_output = self.discriminator(img)
    gan = Mannequin(gan_input, gan_output, identify="GAN")
    gan.compile(loss="binary_crossentropy", optimizer=self.optimizer)
    return gan

Mit dieser Methode wird die kombinierte GAN-Modelldas Generator und Diskriminator stapelt und kompiliert.

Bau des Mills

def build_generator(self):
    generator = Sequential()
    generator.add(Dense(128 * 7 * 7, activatioDCGAN architecturen="relu", input_dim=self.latent_dim))
    generator.add(Reshape((7, 7, 128)))
    generator.add(BatchNormalization(momentum=0.8))
    generator.add(UpSampling2D())
    generator.add(Conv2D(128, kernel_size=3, padding="similar"))
    generator.add(LeakyReLU(0.2))
    generator.add(BatchNormalization(momentum=0.8))
    generator.add(UpSampling2D())
    generator.add(Conv2D(64, kernel_size=3, padding="similar"))
    generator.add(LeakyReLU(0.2))
    generator.add(BatchNormalization(momentum=0.8))
    generator.add(Conv2D(1, kernel_size=3, padding='similar', activation="tanh"))
    return Mannequin(Enter(form=(self.latent_dim,)), generator(Enter(form=(self.latent_dim,))), 
    identify="Generator")

Diese Methode erstellt das Generatormodell und wandelt zufälliges Rauschen in ein synthetisches Bild um.

Aufbau des Diskriminators

def build_discriminator(self):
    discriminator = Sequential()
    discriminator.add(Conv2D(64, kernel_size=(5, 5), strides=(2, 2), padding='similar', 
    input_shape=self.img_shape, 
    kernel_initializer=RandomNormal(stddev=0.02)))
    discriminator.add(LeakyReLU(0.2))
    discriminator.add(Dropout(0.2))
    discriminator.add(Conv2D(128, kernel_size=(5, 5), strides=(2, 2), padding='similar'))
    discriminator.add(LeakyReLU(0.2))
    discriminator.add(Dropout(0.2))
    discriminator.add(Flatten())
    discriminator.add(Dense(1, activation='sigmoid'))
    return Mannequin(Enter(form=self.img_shape), discriminator(Enter(form=self.img_shape)), 
    identify="Discriminator")

Diese Methode erstellt das Diskriminatormodell, das zwischen realen und synthetischen Bildern unterscheidet.

Coaching des DCGAN

def practice(self, X_train, epochs, batch_size=128, sample_interval=50):
    actual = np.ones((batch_size, 1))
    faux = np.zeros((batch_size, 1))
    for epoch in vary(epochs):
        for _ in vary(X_train.form(0) // batch_size):
            idx = np.random.randint(0, X_train.form(0), batch_size)
            imgs = X_train(idx)
            noise = np.random.regular(0, 1, (batch_size, self.latent_dim))
            gen_imgs = self.generator.predict(noise)
            
            d_loss_real = self.discriminator.train_on_batch(imgs, actual)
            d_loss_fake = self.discriminator.train_on_batch(gen_imgs, faux)
            d_loss = 0.5 * np.add(d_loss_real, d_loss_fake)
            
            noise = np.random.regular(0, 1, (batch_size, self.latent_dim))
            g_loss = self.gan.train_on_batch(noise, actual)
        
        if epoch % sample_interval == 0:
            self.sample_images(epoch)

Diese Methode trainiert das DCGAN, indem abwechselnd der Diskriminator und der Generator trainiert werden. Dabei werden in regelmäßigen Abständen Beispielbilder generiert, um den Fortschritt des Mills zu visualisieren.

Bilder abtasten

def sample_images(self, epoch):
    noise = np.random.regular(0, 1, (100, self.latent_dim))
    gen_imgs = self.generator.predict(noise)
    gen_imgs = 0.5 * gen_imgs + 0.5
    
    fig, axs = plt.subplots(10, 10, figsize=(10, 10))
    cnt = 0
    for i in vary(10):
        for j in vary(10):
            axs(i, j).imshow(gen_imgs(cnt, :, :, 0), cmap='grey')
            axs(i, j).axis('off')
            cnt += 1
    plt.present()

Diese Methode generiert und zeigt ein Raster von Bildern an, die der Generator während des Trainings in jedem Abtastintervall erzeugt.

Erstellen und Trainieren des DCGAN

gan = DCGAN()
gan.practice(information, epochs=5, batch_size=128, sample_interval=5)

1. Epoche: Wir sehen, dass die Blumen nicht intestine genug aussehen

Nach vielen Trainingsepochen wird es deutlich besser!

Der Verlust über die Epochen wird angezeigt. Der Generatorverlust scheint zu divergieren. Wir haben jedoch die generierten Samples in jeder Epoche visuell überprüft und die Ergebnisse verbesserten sich.

DCGAN auswerten

Um die Leistung des DCGAN zu bewerten, haben wir es mit anderen Modellen zur Skizzengenerierung verglichen. Wir haben Metriken wie Fréchet Inception Distance (FID), Technology Variety (GD), Attribute Rating (CS) und Semantic Variety Rating (SDS) verwendet.

• Fréchet-Einsatzdistanz (FID): DCGAN erreichte wettbewerbsfähige FID-Werte, was auf eine hohe Qualität der generierten Skizzen hinweist.
• Generationenvielfalt (GD): Das Modell behielt ein hohes Maß an Vielfalt in seinen Ergebnissen bei.
• Charakteristische Bewertung (CS): Dieser Rating misst, wie oft eine generierte Skizze als das beabsichtigte Objekt erkennbar ist, wobei DCGAN gute Ergebnisse erzielt.
• Semantischer Diversitätswert (SDS): Diese Metrik erfasst die verschiedenen generierten Skizzen und zeigt das kreative Potenzial von DCGAN.

Abschluss

Die Fähigkeit von DCGAN, einzigartige, qualitativ hochwertige Skizzen zu erstellen, hat erhebliche Auswirkungen auf verschiedene Anwendungen. Es kann in interaktive Skizzierwerkzeuge integriert werden, um Benutzern kreative Vorschläge zu unterbreiten und Künstlern dabei zu helfen, kreative Blockaden zu überwinden. Der Ansatz des Modells eröffnet neue Möglichkeiten für die Erforschung kollaborativer kreativer Prozesse zwischen Mensch und Maschine.

Zusammenfassend lässt sich sagen, dass DCGAN (Tiefes, konvolutionelles, generatives kontradiktorisches Netzwerk) stellt einen bedeutenden Fortschritt im KI-Design dar. Es setzt einen neuen Commonplace für KI-gesteuerte Kreativität, indem es revolutionary Trainingsmethoden verwendet und sich auf die Erstellung unverwechselbarer, schöner Bilder konzentriert. Da sich künstliche Intelligenz weiterentwickelt, werden Modelle wie DCGAN zweifellos eine wichtige Rolle bei der Entwicklung und Verbesserung der menschlichen Denkfähigkeit spielen.

Häufig gestellte Fragen