El Projecte | Sobre nosaltres | Contribuir | Donacions | Llicència
HOME Els meus cursos Finalitzats
◄ Anterior
◄

Xarxes Generatives Adversarials (GAN)

Següent ►
►

Introducció a les GAN

Les Xarxes Generatives Adversarials (GAN) són una classe de models de deep learning introduïts per Ian Goodfellow i els seus col·laboradors el 2014. Les GAN consisteixen en dues xarxes neuronals que competeixen entre elles: una xarxa generadora (G) i una xarxa discriminadora (D). Aquest enfocament permet generar dades noves que són similars a les dades reals.

Components de les GAN

  1. Generador (G):

    • Té com a objectiu generar dades falses que semblin reals.
    • Pren com a entrada un vector de soroll aleatori i el transforma en una dada sintètica (per exemple, una imatge).

  2. Discriminador (D):

    • Té com a objectiu distingir entre dades reals i dades generades pel generador.
    • Pren com a entrada una dada (real o generada) i produeix una probabilitat que indica si la dada és real o falsa.

Funcionament de les GAN

El procés d'entrenament de les GAN es pot descriure com un joc de suma zero entre el generador i el discriminador:

  • Pas 1: El generador crea dades falses a partir del soroll aleatori.
  • Pas 2: El discriminador avalua tant les dades reals com les dades generades.
  • Pas 3: El discriminador retropropaga l'error, millorant la seva capacitat per distingir entre dades reals i falses.
  • Pas 4: El generador retropropaga l'error, millorant la seva capacitat per enganyar el discriminador.

Aquest procés es repeteix fins que el generador produeix dades que el discriminador no pot distingir de les dades reals.

Algorisme d'Entrenament

L'algorisme d'entrenament de les GAN es pot resumir en els següents passos:

  1. Inicialització: Inicialitzar els pesos del generador \( G \) i del discriminador \( D \).
  2. Entrenament del Discriminador:
    • Prendre un lot de dades reals \( x \) de la distribució de dades reals \( p_{data}(x) \).
    • Generar un lot de dades falses \( G(z) \) utilitzant el generador, on \( z \) és un vector de soroll aleatori.
    • Actualitzar els pesos del discriminador per maximitzar la probabilitat de classificar correctament les dades reals i falses.
  3. Entrenament del Generador:
    • Generar un nou lot de dades falses \( G(z) \).
    • Actualitzar els pesos del generador per minimitzar la probabilitat que el discriminador classifiqui correctament les dades falses.
  4. Repetir: Repetir els passos 2 i 3 fins que el model convergeixi.

Pseudocodi

for number_of_training_steps:
    # Entrenar el discriminador
    for k steps:
        x_real = sample_real_data()
        z = sample_noise()
        x_fake = G(z)
        
        # Actualitzar D per maximitzar log(D(x_real)) + log(1 - D(x_fake))
        update_discriminator(D, x_real, x_fake)
    
    # Entrenar el generador
    z = sample_noise()
    x_fake = G(z)
    
    # Actualitzar G per minimitzar log(1 - D(x_fake))
    update_generator(G, x_fake)

Exemples Pràctics

Exemple 1: Generació d'Imatges

import tensorflow as tf
from tensorflow.keras import layers

# Definir el generador
def build_generator():
    model = tf.keras.Sequential()
    model.add(layers.Dense(256, input_dim=100))
    model.add(layers.LeakyReLU(alpha=0.2))
    model.add(layers.Dense(512))
    model.add(layers.LeakyReLU(alpha=0.2))
    model.add(layers.Dense(1024))
    model.add(layers.LeakyReLU(alpha=0.2))
    model.add(layers.Dense(28 * 28 * 1, activation='tanh'))
    model.add(layers.Reshape((28, 28, 1)))
    return model

# Definir el discriminador
def build_discriminator():
    model = tf.keras.Sequential()
    model.add(layers.Flatten(input_shape=(28, 28, 1)))
    model.add(layers.Dense(512))
    model.add(layers.LeakyReLU(alpha=0.2))
    model.add(layers.Dense(256))
    model.add(layers.LeakyReLU(alpha=0.2))
    model.add(layers.Dense(1, activation='sigmoid'))
    return model

# Compilar els models
generator = build_generator()
discriminator = build_discriminator()
discriminator.compile(optimizer='adam', loss='binary_crossentropy', metrics=['accuracy'])

# Crear el GAN combinat
discriminator.trainable = False
gan_input = layers.Input(shape=(100,))
x = generator(gan_input)
gan_output = discriminator(x)
gan = tf.keras.Model(gan_input, gan_output)
gan.compile(optimizer='adam', loss='binary_crossentropy')

# Entrenament del GAN
def train_gan(gan, generator, discriminator, epochs, batch_size, noise_dim):
    for epoch in range(epochs):
        # Entrenar el discriminador
        real_data = sample_real_data(batch_size)
        noise = sample_noise(batch_size, noise_dim)
        fake_data = generator.predict(noise)
        
        d_loss_real = discriminator.train_on_batch(real_data, np.ones((batch_size, 1)))
        d_loss_fake = discriminator.train_on_batch(fake_data, np.zeros((batch_size, 1)))
        
        # Entrenar el generador
        noise = sample_noise(batch_size, noise_dim)
        g_loss = gan.train_on_batch(noise, np.ones((batch_size, 1)))
        
        # Imprimir les pèrdues
        print(f"Epoch {epoch+1}/{epochs}, Discriminator Loss: {d_loss_real[0] + d_loss_fake[0]}, Generator Loss: {g_loss}")

# Funcions auxiliars
def sample_real_data(batch_size):
    # Implementar la funció per obtenir dades reals
    pass

def sample_noise(batch_size, noise_dim):
    return np.random.normal(0, 1, (batch_size, noise_dim))

# Entrenar el model
train_gan(gan, generator, discriminator, epochs=10000, batch_size=64, noise_dim=100)

Exemple 2: Generació de Text

# Aquest exemple és més complex i requeriria un enfocament diferent, com l'ús de RNNs o Transformers per al generador i el discriminador.
# Per simplicitat, aquest exemple es deixa com a exercici per al lector.

Exercicis Pràctics

Exercici 1: Implementar una GAN per Generar Imatges de Dígits

  1. Objectiu: Implementar una GAN que generi imatges de dígits manuscrits utilitzant el conjunt de dades MNIST.
  2. Passos:
    • Carregar el conjunt de dades MNIST.
    • Construir el generador i el discriminador.
    • Entrenar la GAN.
    • Visualitzar les imatges generades.

Exercici 2: Experimentar amb Diferents Arquitectures

  1. Objectiu: Experimentar amb diferents arquitectures de generador i discriminador per veure com afecten la qualitat de les imatges generades.
  2. Passos:
    • Modificar les capes del generador i del discriminador.
    • Entrenar la GAN amb les noves arquitectures.
    • Comparar els resultats.

Errors Comuns i Consells

  • Mode Collapse: El generador produeix una varietat limitada de mostres. Per evitar-ho, es poden utilitzar tècniques com la regularització de gradient o la penalització de gradient.
  • Entrenament Desbalancejat: Si el discriminador és massa fort, el generador no aprèn. És important equilibrar l'entrenament de les dues xarxes.
  • Hiperparàmetres: L'elecció dels hiperparàmetres (com la taxa d'aprenentatge) és crucial per a l'èxit de les GAN. Experimentar amb diferents valors pot ajudar a trobar la configuració òptima.

Conclusió

Les Xarxes Generatives Adversarials són una eina poderosa per generar dades sintètiques que semblen reals. Tot i que l'entrenament de les GAN pot ser complex i requereix una cura especial en l'ajust dels hiperparàmetres, els resultats poden ser sorprenents i útils en una àmplia gamma d'aplicacions. Amb la pràctica i l'experimentació, es poden aconseguir models generatius molt efectius.

◄ Anterior
◄
Següent ►
►
El Projecte | Sobre nosaltres | Contribuir | Donacions | Llicència
© Copyright 2024. Tots els drets reservats