SIN EMBARGO (Generative Adversarial Network) representa un enfoque de vanguardia para el modelado generativo dentro del aprendizaje profundo, que a menudo aprovecha arquitecturas como redes neuronales convolucionales . El objetivo del modelado generativo es identificar de forma autónoma patrones en los datos de entrada, permitiendo que el modelo produzca nuevos ejemplos que se parezcan factiblemente al conjunto de datos original.

Este artículo cubre todo lo que necesita saber sobre GAN, la arquitectura de GAN, el funcionamiento de GAN y los tipos de modelos GAN, etc.

Tabla de contenidos

• ¿Qué es una red generativa adversaria?
• Tipos de GAN
• Arquitectura de GAN
• ¿Cómo funciona una GAN?
• Implementación de una GAN
• Aplicación de redes generativas adversarias (GAN)
• Ventajas de GAN
• Desventajas de GAN
• GAN (Red de confrontación generativa): preguntas frecuentes

¿Qué es una red generativa adversaria?

Las redes generativas adversarias (GAN) son una poderosa clase de redes neuronales que se utilizan para una aprendizaje sin supervisión . Las GAN se componen de dos Redes neuronales , un discriminador y un generador. Utilizan entrenamiento adversario para producir datos artificiales que sean idénticos a los datos reales.

• El Generador intenta engañar al Discriminador, que tiene la tarea de distinguir con precisión entre los datos producidos y los genuinos, produciendo muestras de ruido aleatorias.
• Como resultado de esta interacción competitiva, se producen muestras realistas y de alta calidad, lo que impulsa a ambas redes hacia el avance.
• Las GAN están demostrando ser herramientas de inteligencia artificial muy versátiles, como lo demuestra su amplio uso en síntesis de imágenes, transferencia de estilos y síntesis de texto a imagen.
• También han revolucionado el modelado generativo.

A través del entrenamiento adversario, estos modelos participan en una interacción competitiva hasta que el generador se vuelve experto en crear muestras realistas, engañando al discriminador aproximadamente la mitad de las veces.

Las redes generativas adversarias (GAN) se pueden dividir en tres partes:

• Generativo: Aprender un modelo generativo, que describe cómo se generan los datos en términos de un modelo probabilístico.
• Adversario: La palabra adversario se refiere a oponer una cosa a otra. Esto significa que, en el contexto de las GAN, el resultado generativo se compara con las imágenes reales del conjunto de datos. Se utiliza un mecanismo conocido como discriminador para aplicar un modelo que intenta distinguir entre imágenes reales y falsas.
• Redes: Utilice redes neuronales profundas como algoritmos de inteligencia artificial (IA) con fines de capacitación.

Tipos de GAN

1. Vainilla GAN: Este es el tipo más simple de GAN. Aquí, el Generador y el Discriminador son simples y básicos. perceptrones multicapa . En vanilla GAN, el algoritmo es realmente simple, intenta optimizar la ecuación matemática usando descenso de gradiente estocástico.
2. GAN condicional (CGAN): CGAN puede describirse como un aprendizaje profundo método en el que Se implementan algunos parámetros condicionales. .
   • En CGAN, se agrega un parámetro adicional 'y' al Generador para generar los datos correspondientes.
   • También se colocan etiquetas en la entrada del Discriminador para que éste ayude a distinguir los datos reales de los datos falsos generados.
3. GAN convolucional profunda (DCGAN): DCGAN es una de las implementaciones más populares y también de mayor éxito de GAN. Esta compuesto de ConvNets en lugar de perceptrones multicapa .
   • Las ConvNets se implementan sin agrupación máxima, que de hecho se reemplaza por un paso convolucional.
   • Además, las capas no están completamente conectadas.
4. Pirámide Laplaciana GAN (LAPGAN): El pirámide laplaciana es una representación de imagen lineal invertible que consta de un conjunto de imágenes de paso de banda, espaciadas una octava, más un residual de baja frecuencia.
   • Este enfoque utiliza múltiples números de redes generadoras y discriminadoras y diferentes niveles de la pirámide laplaciana.
   • Este enfoque se utiliza principalmente porque produce imágenes de muy alta calidad. La imagen se muestra primero en cada capa de la pirámide y luego se vuelve a escalar en cada capa en un paso hacia atrás donde la imagen adquiere algo de ruido de la GAN condicional en estas capas hasta que alcanza su tamaño original.
5. GAN de súper resolución (SRGAN): SRGAN como su nombre indica es una forma de diseñar una GAN en la que un red neuronal profunda se utiliza junto con una red adversaria para producir imágenes de mayor resolución. Este tipo de GAN es particularmente útil para escalar de manera óptima imágenes nativas de baja resolución para mejorar sus detalles y minimizar los errores al hacerlo.

Arquitectura de GAN

Una Red Generativa Adversaria (GAN) se compone de dos partes principales, que son el Generador y el Discriminador.

Modelo de generador

Un elemento clave responsable de crear datos nuevos y precisos en una Red Generativa Adversaria (GAN) es el modelo generador. El generador toma ruido aleatorio como entrada y lo convierte en muestras de datos complejos, como texto o imágenes. Comúnmente se representa como una red neuronal profunda.

La distribución subyacente de los datos de entrenamiento se captura mediante capas de parámetros que se pueden aprender en su diseño a través del entrenamiento. El generador ajusta su salida para producir muestras que imitan fielmente los datos reales mientras se entrena mediante el uso de retropropagación para ajustar sus parámetros.

La capacidad del generador para generar muestras variadas y de alta calidad que puedan engañar al discriminador es lo que lo hace exitoso.

Pérdida del generador

El objetivo del generador en una GAN es producir muestras sintéticas que sean lo suficientemente realistas como para engañar al discriminador. El generador logra esto minimizando su función de pérdida.J_G​. La pérdida se minimiza cuando se maximiza la probabilidad logarítmica, es decir, cuando es muy probable que el discriminador clasifique las muestras generadas como reales. La siguiente ecuación se da a continuación:

J_{G} = -frac{1}{m} Sigma^m _{i=1} log D(G(z_{i}))
Dónde,

• J_G medir qué tan bien el generador está engañando al discriminador.
• registroD(G(z_i) )representa la probabilidad logarítmica de que el discriminador sea correcto para las muestras generadas.
• El generador pretende minimizar esta pérdida, fomentando la producción de muestras que el discriminador clasifica como reales.(log D(G(z_i)), cerca de 1.

Modelo discriminador

En las redes generativas adversarias (GAN) se utiliza una red neuronal artificial llamada modelo discriminador para diferenciar entre la entrada generada y la real. Al evaluar muestras de entrada y asignar probabilidad de autenticidad, el discriminador funciona como un clasificador binario.

Con el tiempo, el discriminador aprende a diferenciar entre datos genuinos del conjunto de datos y muestras artificiales creadas por el generador. Esto le permite perfeccionar progresivamente sus parámetros y aumentar su nivel de competencia.

Capas convolucionales o se suelen utilizar estructuras pertinentes para otras modalidades en su arquitectura cuando se trata de datos de imágenes. Maximizar la capacidad del discriminador para identificar con precisión las muestras generadas como fraudulentas y las muestras reales como auténticas es el objetivo del procedimiento de entrenamiento adversarial. El discriminador se vuelve cada vez más discriminante como resultado de la interacción del generador y el discriminador, lo que ayuda a la GAN a producir datos sintéticos de apariencia extremadamente realista en general.

Pérdida del discriminador

El discriminador reduce la probabilidad logarítmica negativa de clasificar correctamente tanto las muestras producidas como las reales. Esta pérdida incentiva al discriminador a categorizar con precisión las muestras generadas como muestras falsas y reales con la siguiente ecuación:
J_{D} = -frac{1}{m} Sigma_{i=1}^m log; D(x_{i}) – frac{1}{m}Sigma_{i=1}^m log(1 – D(G(z_{i}))

• J_DEvalúa la capacidad del discriminador para discernir entre muestras producidas y reales.
• La probabilidad logarítmica de que el discriminador categorice con precisión los datos reales está representada porlogD(x_i).
• La probabilidad logarítmica de que el discriminador categorice correctamente las muestras generadas como falsas está representada porlog⁡(1-D(G(z_i))).
• El discriminador tiene como objetivo reducir esta pérdida identificando con precisión muestras reales y artificiales.

Pérdida mínima máxima

En una Red Generativa Adversaria (GAN), la fórmula de pérdida minimax viene proporcionada por:

min_{G};max_{D}(G,D) = [mathbb{E}_{x∼p_{data}}[log;D(x)] + mathbb{E}_{z∼p_{z}(z)}[log(1 – D(g(z)))]
Dónde,

• G es la red generadora y D es la red discriminadora.
• Muestras de datos reales obtenidas de la distribución de datos reales.p_{data}(x) están representados por x.
• Ruido aleatorio muestreado de una distribución anterior.p_z(z) (normalmente una distribución normal o uniforme) está representada por z.
• D (x) representa la probabilidad del discriminador de identificar correctamente los datos reales como reales.
• D(G(z)) es la probabilidad de que el discriminador identifique los datos generados provenientes del generador como auténticos.

¿Cómo funciona una GAN?

Los pasos involucrados en cómo funciona una GAN:

1. Inicialización: Se crean dos redes neuronales: un Generador (G) y un Discriminador (D).
   • G tiene la tarea de crear nuevos datos, como imágenes o texto, que se parezcan mucho a los datos reales.
   • D actúa como crítico, tratando de distinguir entre datos reales (de un conjunto de datos de entrenamiento) y los datos generados por G.
2. El primer movimiento del generador: G toma un vector de ruido aleatorio como entrada. Este vector de ruido contiene valores aleatorios y actúa como punto de partida para el proceso de creación de G. Utilizando sus capas internas y patrones aprendidos, G transforma el vector de ruido en una nueva muestra de datos, como una imagen generada.
3. El turno del discriminador: D recibe dos tipos de entradas:
   • Muestras de datos reales del conjunto de datos de entrenamiento.
   • Las muestras de datos generadas por G en el paso anterior. El trabajo de D es analizar cada entrada y determinar si son datos reales o algo inventado por G. Genera una puntuación de probabilidad entre 0 y 1. Una puntuación de 1 indica que los datos probablemente sean reales y 0 sugiere que son falsos.
4. El proceso de aprendizaje: Ahora viene la parte contradictoria:
   • Si D identifica correctamente los datos reales como reales (puntuación cercana a 1) y los datos generados como falsos (puntuación cercana a 0), tanto G como D son recompensados ​​en pequeña medida. Esto se debe a que ambos están haciendo bien su trabajo.
   • Sin embargo, la clave es mejorar continuamente. Si D identifica todo correctamente de forma constante, no aprenderá mucho. Entonces, el objetivo es que G eventualmente engañe a D.
5. Mejora del generador:
   • Cuando D etiqueta erróneamente la creación de G como real (puntuación cercana a 1), es una señal de que G está en el camino correcto. En este caso, G recibe una importante actualización positiva, mientras que D recibe una penalización por haber sido engañado.
   • Esta retroalimentación ayuda a G a mejorar su proceso de generación para crear datos más realistas.
6. Adaptación del discriminador:
   • Por el contrario, si D identifica correctamente los datos falsos de G (puntuación cercana a 0), pero G no recibe ninguna recompensa, D se fortalece aún más en sus capacidades de discriminación.
   • Este duelo en curso entre G y D perfecciona ambas redes con el tiempo.

A medida que avanza el entrenamiento, G mejora en la generación de datos realistas, lo que hace que a D le resulte más difícil notar la diferencia. Idealmente, G se vuelve tan hábil que D no puede distinguir de manera confiable los datos reales de los falsos. En este punto, se considera que G está bien entrenado y puede usarse para generar muestras de datos nuevas y realistas.

configuración de ruta de Python

Implementación de la Red Generativa Adversaria (GAN)

Seguiremos y comprenderemos los pasos para comprender cómo se implementa GAN:

Paso 1: Importar las bibliotecas necesarias

Python3

   For training on the CIFAR-10 image dataset, this  PyTorch  module creates a Generative Adversarial Network (GAN), switching between generator and discriminator training. Visualization of the generated images occurs every tenth epoch, and the development of the GAN is tracked. Step 2: Defining a TransformThe code uses PyTorch’s transforms to define a simple picture transforms.Compose. It normalizes and transforms photos into tensors. Python3         # Define a basic transform transform = transforms.Compose([  transforms.ToTensor(),  transforms.Normalize((0.5, 0.5, 0.5), (0.5, 0.5, 0.5)) ])        Step 3: Loading the Dataset  A  CIFAR-10 dataset  is created for training with below code, which also specifies a root directory, turns on train mode, downloads if needed, and applies the specified transform. Subsequently, it generates a 32-batch  DataLoader  and shuffles the training set of data. Python3         train_dataset = datasets.CIFAR10(root='./data',  train=True, download=True, transform=transform) dataloader = torch.utils.data.DataLoader(train_dataset,   batch_size=32, shuffle=True)         Step 4: Defining parameters to be used in later processes  A Generative Adversarial Network (GAN) is used with specified hyperparameters.  The latent space’s dimensionality is represented by latent_dim. lr is the optimizer’s learning rate. The coefficients for the  Adam optimizer  are beta1 and beta2. To find the total number of training epochs, use num_epochs. Python3         # Hyperparameters latent_dim = 100 lr = 0.0002 beta1 = 0.5 beta2 = 0.999 num_epochs = 10        Step 5: Defining a Utility Class to Build the Generator  The generator architecture for a GAN in PyTorch is defined with below code.  From  nn.Module , the Generator class inherits. It is comprised of a sequential model with Tanh, linear, convolutional, batch normalization, reshaping, and upsampling layers. The neural network synthesizes an image (img) from a latent vector (z), which is the generator’s output. The architecture uses a series of learned transformations to turn the initial random noise in the latent space into a meaningful image. Python3         # Define the generator class Generator(nn.Module):  def __init__(self, latent_dim):  super(Generator, self).__init__()  self.model = nn.Sequential(  nn.Linear(latent_dim, 128 * 8 * 8),  nn.ReLU(),  nn.Unflatten(1, (128, 8, 8)),  nn.Upsample(scale_factor=2),  nn.Conv2d(128, 128, kernel_size=3, padding=1),  nn.BatchNorm2d(128, momentum=0.78),  nn.ReLU(),  nn.Upsample(scale_factor=2),  nn.Conv2d(128, 64, kernel_size=3, padding=1),  nn.BatchNorm2d(64, momentum=0.78),  nn.ReLU(),  nn.Conv2d(64, 3, kernel_size=3, padding=1),  nn.Tanh()  )  def forward(self, z):  img = self.model(z)  return img        Step 6: Defining a Utility Class to Build the Discriminator  The PyTorch code describes the discriminator architecture for a GAN. The class Discriminator is descended from nn.Module. It is composed of linear layers, batch normalization,  dropout , convolutional,  LeakyReLU , and sequential layers.  An image (img) is the discriminator’s input, and its validity—the probability that the input image is real as opposed to artificial—is its output.  Python3         # Define the discriminator class Discriminator(nn.Module):  def __init__(self):  super(Discriminator, self).__init__()  self.model = nn.Sequential(  nn.Conv2d(3, 32, kernel_size=3, stride=2, padding=1),  nn.LeakyReLU(0.2),  nn.Dropout(0.25),  nn.Conv2d(32, 64, kernel_size=3, stride=2, padding=1),  nn.ZeroPad2d((0, 1, 0, 1)),  nn.BatchNorm2d(64, momentum=0.82),  nn.LeakyReLU(0.25),  nn.Dropout(0.25),  nn.Conv2d(64, 128, kernel_size=3, stride=2, padding=1),  nn.BatchNorm2d(128, momentum=0.82),  nn.LeakyReLU(0.2),  nn.Dropout(0.25),  nn.Conv2d(128, 256, kernel_size=3, stride=1, padding=1),  nn.BatchNorm2d(256, momentum=0.8),  nn.LeakyReLU(0.25),  nn.Dropout(0.25),  nn.Flatten(),  nn.Linear(256 * 5 * 5, 1),  nn.Sigmoid()  )  def forward(self, img):  validity = self.model(img)  return validity        Step 7: Building the Generative Adversarial Network  The code snippet defines and initializes a discriminator (Discriminator) and a generator (Generator).  The designated device (GPU if available) receives both models.  Binary Cross Entropy Loss,  which is frequently used for GANs, is selected as the loss function (adversarial_loss). For the generator (optimizer_G) and discriminator (optimizer_D), distinct Adam optimizers with predetermined learning rates and betas are also defined.  Python3         # Define the generator and discriminator # Initialize generator and discriminator generator = Generator(latent_dim).to(device) discriminator = Discriminator().to(device) # Loss function adversarial_loss = nn.BCELoss() # Optimizers optimizer_G = optim.Adam(generator.parameters()  , lr=lr, betas=(beta1, beta2)) optimizer_D = optim.Adam(discriminator.parameters()  , lr=lr, betas=(beta1, beta2))        Step 8: Training the Generative Adversarial Network  For a Generative Adversarial Network (GAN), the code implements the training loop.  The training data batches are iterated through during each epoch. Whereas the generator (optimizer_G) is trained to generate realistic images that trick the discriminator, the discriminator (optimizer_D) is trained to distinguish between real and phony images. The generator and discriminator’s adversarial losses are computed. Model parameters are updated by means of Adam optimizers and the losses are backpropagated. Discriminator printing and generator losses are used to track progress. For a visual assessment of the training process, generated images are additionally saved and shown every 10 epochs. Python3         # Training loop for epoch in range(num_epochs):  for i, batch in enumerate(dataloader):  # Convert list to tensor  real_images = batch[0].to(device)   # Adversarial ground truths  valid = torch.ones(real_images.size(0), 1, device=device)  fake = torch.zeros(real_images.size(0), 1, device=device)  # Configure input  real_images = real_images.to(device)  # ---------------------  # Train Discriminator  # ---------------------  optimizer_D.zero_grad()  # Sample noise as generator input  z = torch.randn(real_images.size(0), latent_dim, device=device)  # Generate a batch of images  fake_images = generator(z)  # Measure discriminator's ability   # to classify real and fake images  real_loss = adversarial_loss(discriminator  (real_images), valid)  fake_loss = adversarial_loss(discriminator  (fake_images.detach()), fake)  d_loss = (real_loss + fake_loss) / 2  # Backward pass and optimize  d_loss.backward()  optimizer_D.step()  # -----------------  # Train Generator  # -----------------  optimizer_G.zero_grad()  # Generate a batch of images  gen_images = generator(z)  # Adversarial loss  g_loss = adversarial_loss(discriminator(gen_images), valid)  # Backward pass and optimize  g_loss.backward()  optimizer_G.step()  # ---------------------  # Progress Monitoring  # ---------------------  if (i + 1) % 100 == 0:  print(  f'Epoch [{epoch+1}/{num_epochs}]  Batch {i+1}/{len(dataloader)} '  f'Discriminator Loss: {d_loss.item():.4f} '  f'Generator Loss: {g_loss.item():.4f}'  )  # Save generated images for every epoch  if (epoch + 1) % 10 == 0:  with torch.no_grad():  z = torch.randn(16, latent_dim, device=device)  generated = generator(z).detach().cpu()  grid = torchvision.utils.make_grid(generated,  nrow=4, normalize=True)  plt.imshow(np.transpose(grid, (1, 2, 0)))  plt.axis('off')  plt.show()        Output:   Epoch [10/10] Batch 1300/1563 Discriminator Loss: 0.4473 Generator Loss: 0.9555 Epoch [10/10] Batch 1400/1563 Discriminator Loss: 0.6643 Generator Loss: 1.0215 Epoch [10/10] Batch 1500/1563 Discriminator Loss: 0.4720 Generator Loss: 2.5027  GAN Output Application Of Generative Adversarial Networks (GANs)GANs, or Generative Adversarial Networks, have many uses in many different fields. Here are some of the widely recognized uses of GANs:   Image Synthesis and Generation : GANs   are often used for picture synthesis and generation tasks, They may create fresh, lifelike pictures that mimic training data by learning the distribution that explains the dataset. The development of lifelike avatars, high-resolution photographs, and fresh artwork have all been facilitated by these types of generative networks.  Image-to-Image Translation : GANs   may be used for problems involving image-to-image translation, where the objective is to convert an input picture from one domain to another while maintaining its key features. GANs may be used, for instance, to change pictures from day to night, transform drawings into realistic images, or change the creative style of an image.  Text-to-Image Synthesis : GANs   have been used to create visuals from descriptions in text. GANs may produce pictures that translate to a description given a text input, such as a phrase or a caption. This application might have an impact on how realistic visual material is produced using text-based instructions.  Data Augmentation : GANs   can augment present data and increase the robustness and generalizability of machine-learning models by creating synthetic data samples.  Data Generation for Training : GANs   can enhance the resolution and quality of low-resolution images. By training on pairs of low-resolution and high-resolution images, GANs can generate high-resolution images from low-resolution inputs, enabling improved image quality in various applications such as medical imaging, satellite imaging, and video enhancement.Advantages of GANThe advantages of the GANs are as follows:   Synthetic data generation  : GANs can generate new, synthetic data that resembles some known data distribution, which can be useful for data augmentation, anomaly detection, or creative applications.  High-quality results  : GANs can produce high-quality, photorealistic results in image synthesis, video synthesis, music synthesis, and other tasks.  Unsupervised learning  : GANs can be trained without labeled data, making them suitable for unsupervised learning tasks, where labeled data is scarce or difficult to obtain.  Versatility  : GANs can be applied to a wide range of tasks, including image synthesis, text-to-image synthesis, image-to-image translation,  anomaly detection ,  The disadvantages of the GANs are as follows:   Training Instability  : GANs can be difficult to train, with the risk of instability, mode collapse, or failure to converge.  Computational Cost  : GANs can require a lot of computational resources and can be slow to train, especially for high-resolution images or large datasets.  Overfitting  : GANs can overfit the training data, producing synthetic data that is too similar to the training data and lacking diversity.  Bias and Fairness  : GANs can reflect the biases and unfairness present in the training data, leading to discriminatory or biased synthetic data.  Interpretability and Accountability  : GANs can be opaque and difficult to interpret or explain, making it challenging to ensure accountability, transparency, or fairness in their applications.GAN(Generative Adversarial Network)- FAQs Q1. What is a Generative Adversarial Network(GAN)?An artificial intelligence model known as a GAN is made up of two neural networks—a discriminator and a generator—that were developed in tandem using adversarial training. The discriminator assesses the new data instances for authenticity, while the generator produces new ones. Q2. What are the main applications of GAN?Generating images and videos, transferring styles, enhancing data, translating images to other images, producing realistic synthetic data for machine learning model training, and super-resolution are just a few of the many uses for GANs. Q3. What challenges do GAN face?GANs encounter difficulties such training instability, mode collapse (when the generator generates a limited range of samples), and striking the correct balance between the discriminator and generator. It’s frequently necessary to carefully build the model architecture and tune the hyperparameters. Q4. How are GAN evaluated?The produced samples’ quality, diversity, and resemblance to real data are the main criteria used to assess GANs. For quantitative assessment, metrics like the Fréchet Inception Distance (FID) and Inception Score are frequently employed. Q5.   Can GAN be used for tasks other than image generation  ?Yes, different tasks can be assigned to GANs. Text, music, 3D models, and other things have all been generated with them. The usefulness of conditional GANs is expanded by enabling the creation of specific content under certain input conditions. Q6.   What are some famous architectures of GANs  ?A few well-known GAN architectures are Progressive GAN (PGAN), Wasserstein GAN (WGAN), Conditional GAN (cGAN), Deep Convolutional GAN (DCGAN), and Vanilla GAN. Each has special qualities and works best with particular kinds of data and tasks.>