Guida passo-passo per la creazione di un modello DCGAN

Guida per creare un modello DCGAN

Introduzione

Le Deep Convolutional Generative Adversarial Networks (DCGANs) hanno rivoluzionato il campo della generazione di immagini combinando la potenza delle Generative Adversarial Networks (GANs) e delle reti neurali convoluzionali (CNNs). I modelli DCGAN possono creare immagini incredibilmente realistiche, rendendoli uno strumento essenziale in diverse applicazioni creative, come la generazione di arte, la modifica delle immagini e l’aumento dei dati. In questa guida passo-passo, ti guideremo nel processo di costruzione di un modello DCGAN utilizzando Python e TensorFlow.

Le DCGAN si sono rivelate preziose in campi che spaziano dall’arte all’intrattenimento, consentendo agli artisti di creare esperienze visive nuove. Inoltre, nell’imaging medico, le DCGAN aiutano a generare scansioni ad alta risoluzione per una diagnosi accurata. Il loro ruolo nell’aumento dei dati migliora i modelli di apprendimento automatico mentre contribuiscono all’architettura e al design degli interni simulando ambienti realistici. Mescolando creatività e tecnologia in modo fluido, le DCGAN hanno superato il concetto di semplici algoritmi per catalizzare progressi innovativi in diversi ambiti. Alla fine di questo tutorial, avrai un’implementazione DCGAN ben strutturata in grado di generare immagini di alta qualità da rumore casuale.

Questo articolo è stato pubblicato come parte del Data Science Blogathon.

• Ricercatori dell’UC Berkeley presentano Dynalang un agente di intelligenza artificiale che apprende un modello di mondo multimodale per prevedere rappresentazioni future di testo e immagini e impara ad agire tramite simulazioni immaginate del modello.
• L’Importanza della Pulizia dei Dati nella Scienza dei Dati
• Alibaba mette a disposizione in open source un modello di intelligenza artificiale per sfidare Meta e potenziare gli sviluppatori

Prerequisiti

Prima di iniziare l’implementazione, assicurati di avere installate le seguenti librerie:

• TensorFlow: pip install tensorflow
• NumPy: pip install numpy
• Matplotlib: pip install matplotlib

Assicurati di avere una comprensione di base delle GAN e delle reti neurali convoluzionali. La familiarità con Python e TensorFlow sarà anche utile.

Dataset

Per dimostrare il modello DCGAN, utilizzeremo il famoso dataset MNIST contenente immagini in scala di grigi di cifre scritte a mano da 0 a 9. Ogni immagine è un quadrato di 28×28 pixel, rendendolo un dataset perfetto. Il dataset MNIST viene pre-caricato con TensorFlow, rendendolo facile da accedere e utilizzare.

Importazioni

Iniziamo importando le librerie necessarie:

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

Generatore e Discriminatore

Successivamente, definiremo le reti del generatore e del discriminatore.

Generatore

Il generatore prende in input un rumore casuale e genera immagini false. Tipicamente è composto da strati di convoluzione trasposta, noti anche come strati di deconvoluzione. L’obiettivo del generatore è di mappare il rumore casuale dallo spazio latente allo spazio dei dati e generare immagini indistinguibili da quelle reali.

def build_generator(latent_dim):
    model = models.Sequential()

    model.add(layers.Dense(7 * 7 * 256, use_bias=False, input_shape=(latent_dim,)))
    model.add(layers.BatchNormalization())
    model.add(layers.LeakyReLU())

    model.add(layers.Reshape((7, 7, 256)))
    assert model.output_shape == (None, 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'))
    assert model.output_shape == (None, 28, 28, 1)

    return model

Discriminatore

Il discriminatore è responsabile di distinguere tra immagini reali e false. È una rete di classificazione binaria che prende in input immagini e restituisce una probabilità che indica se l’immagine di input è reale o falsa.

def build_discriminator():
    model = models.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

Creazione del DCGAN

Creiamo il DCGAN combinando i generatori e i discriminatori. A tal fine, definiremo una funzione chiamata build_dcgan che prenderà generatori e discriminatori come argomenti.

def build_dcgan(generator, discriminator):
    model = models.Sequential()
    model.add(generator)
    discriminator.trainable = False
    model.add(discriminator)
    return model

Allenamento del DCGAN

Prima di iniziare l’allenamento, dobbiamo compilare il modello DCGAN. Il discriminatore e il generatore saranno allenati separatamente, ma inizieremo compilando prima il discriminatore.

latent_dim = 100
generator = build_generator(latent_dim)
discriminator = build_discriminator()
dcgan = build_dcgan(generator, discriminator)

discriminator.compile(optimizer=tf.keras.optimizers.Adam(learning_rate=0.0002, beta_1=0.5),
                      loss=tf.keras.losses.BinaryCrossentropy(from_logits=True))
dcgan.compile(optimizer=tf.keras.optimizers.Adam(learning_rate=0.0002, beta_1=0.5),
              loss=tf.keras.losses.BinaryCrossentropy(from_logits=True))

In seguito, prepareremo il dataset e implementeremo il ciclo di allenamento. Gli iperparametri che stiamo impostando per questo passaggio sono iterativi e possono essere regolati a seconda della precisione richiesta.

# Carica e preelabora il dataset
(train_images, _), (_, _) = 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

# Iperparametri
batch_size = 128
epochs = 50
buffer_size = 60000
steps_per_epoch = buffer_size // batch_size
seed = np.random.normal(0, 1, (16, latent_dim))

# Crea un oggetto Dataset
train_dataset = tf.data.Dataset.from_tensor_slices(train_images).shuffle(buffer_size).batch(batch_size)

# Ciclo di allenamento
for epoch in range(epochs):
    for step, real_images in enumerate(train_dataset):
        # Genera rumore casuale
        noise = np.random.normal(0, 1, (batch_size, latent_dim))

        # Genera immagini false
        generated_images = generator.predict(noise)

        # Combina immagini reali e false
        combined_images = np.concatenate([real_images, generated_images])

        # Etichette per il discriminatore
        labels = np.concatenate([np.ones((batch_size, 1)), np.zeros((batch_size, 1))])

        # Aggiungi rumore alle etichette (importante per l'apprendimento del discriminatore)
        labels += 0.05 * np.random.random(labels.shape)

        # Allena il discriminatore
        d_loss = discriminator.train_on_batch(combined_images, labels)

        # Allena il generatore
        noise = np.random.normal(0, 1, (batch_size, latent_dim))
        misleading_labels = np.ones((batch_size, 1))
        g_loss = dcgan.train_on_batch(noise, misleading_labels)

    # Mostra il progresso
    print(f"Epoca {epoch}/{epochs}, Perdita del discriminatore: {d_loss}, Perdita del generatore: {g_loss}")

    # Salva le immagini generate ogni qualche epoca
    if epoch % 10 == 0:
        generate_and_save_images(generator, epoch + 1, seed)

# Salva il modello del generatore
generator.save('dcgan_generator.h5')

Generazione di immagini

Per generare immagini, possiamo utilizzare il generatore allenato. Ecco una funzione che ci aiuterà a visualizzare le immagini generate:

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] + 1) / 2.0, cmap='gray')
        plt.axis('off')

    plt.savefig(f"image_at_epoch_{epoch:04d}.png")
    plt.close()

Conclusion

In conclusione, questa guida completa ha svelato le complessità nel creare un modello di Deep Convolutional Generative Adversarial Network (DCGAN) utilizzando Python e TensorFlow. Combinando la potenza delle GAN e delle reti convoluzionali, abbiamo dimostrato come generare immagini realistiche a partire da rumore casuale. Dotati di una chiara comprensione dell’interazione tra generatore e discriminatore e dell’ottimizzazione degli iperparametri, potete intraprendere viaggi immaginativi nell’arte, nell’aumento dei dati e oltre. Le DCGAN rappresentano un testamento alla notevole sinergia tra creatività e tecnologia.

Punti chiave

• Le DCGAN combinano le GAN con le reti neurali convoluzionali, rendendole efficaci per compiti di generazione di immagini.
• Il generatore mappa il rumore casuale nello spazio dei dati per produrre immagini fittizie, mentre il discriminatore distingue tra immagini reali e fittizie.
• Il modello DCGAN deve essere compilato e addestrato attentamente separatamente per il generatore e il discriminatore.
• La scelta degli iperparametri, come il tasso di apprendimento, la dimensione del batch e il numero di epoche di addestramento, influisce significativamente sulle prestazioni del modello.
• La qualità delle immagini generate migliora con tempi di addestramento più lunghi e con hardware più potente.

Sperimentare con le DCGAN apre possibilità entusiasmanti per applicazioni creative, come la generazione di arte, la creazione di personaggi virtuali e il miglioramento dell’aumento dei dati per vari compiti di machine learning. La generazione di dati sintetici può anche essere preziosa quando i dati reali sono scarsi o inaccessibili.

Domande frequenti

I media mostrati in questo articolo non sono di proprietà di Analytics Vidhya e sono utilizzati a discrezione dell’autore.