CEPENDANT (Generative Adversarial Network) représente une approche de pointe de la modélisation générative au sein de l'apprentissage profond, exploitant souvent des architectures telles que réseaux de neurones convolutifs . L'objectif de la modélisation générative est d'identifier de manière autonome des modèles dans les données d'entrée, permettant au modèle de produire de nouveaux exemples qui ressemblent de manière réaliste à l'ensemble de données d'origine.

Cet article couvre tout ce que vous devez savoir sur GAN, l'architecture du GAN, le fonctionnement du GAN et les types de modèles GAN, etc.

Table des matières

• Qu’est-ce qu’un réseau contradictoire génératif ?
• Types de GAN
• Architecture des GAN
• Comment fonctionne un GAN ?
• Mise en place d'un GAN
• Application des réseaux contradictoires génératifs (GAN)
• Avantages du GAN
• Inconvénients du GAN
• GAN (Generative Adversarial Network) – FAQ

Qu’est-ce qu’un réseau contradictoire génératif ?

Les réseaux contradictoires génératifs (GAN) sont une classe puissante de réseaux neuronaux utilisés pour un apprentissage non supervisé . Les GAN sont composés de deux les réseaux de neurones , un discriminateur et un générateur. Ils utilisent un entraînement contradictoire pour produire des données artificielles identiques aux données réelles.

• Le générateur tente de tromper le discriminateur, chargé de distinguer avec précision les données produites des données authentiques, en produisant des échantillons de bruit aléatoires.
• Des échantillons réalistes et de haute qualité sont produits grâce à cette interaction compétitive, qui pousse les deux réseaux vers l’avancement.
• Les GAN se révèlent être des outils d’intelligence artificielle très polyvalents, comme en témoigne leur utilisation intensive dans la synthèse d’images, le transfert de style et la synthèse texte-image.
• Ils ont également révolutionné la modélisation générative.

Grâce à un entraînement contradictoire, ces modèles s'engagent dans une interaction compétitive jusqu'à ce que le générateur devienne apte à créer des échantillons réalistes, trompant le discriminateur environ la moitié du temps.

Les réseaux contradictoires génératifs (GAN) peuvent être divisés en trois parties :

• Génératif: Apprendre un modèle génératif, qui décrit comment les données sont générées en termes de modèle probabiliste.
• Conversatoire : Le mot contradictoire fait référence à l’opposition d’une chose à une autre. Cela signifie que, dans le contexte des GAN, le résultat généré est comparé aux images réelles de l'ensemble de données. Un mécanisme appelé discriminateur est utilisé pour appliquer un modèle qui tente de distinguer les images réelles des fausses.
• Réseaux : Utilisez des réseaux de neurones profonds comme algorithmes d’intelligence artificielle (IA) à des fins de formation.

Types de GAN

1. GAN vanille : C'est le type de GAN le plus simple. Ici, le Générateur et le Discriminateur sont simples et basiques. perceptrons multicouches . Dans Vanilla GAN, l'algorithme est vraiment simple, il essaie d'optimiser l'équation mathématique en utilisant descente de gradient stochastique.
2. GAN conditionnel (CGAN) : CGAN peut être décrit comme un l'apprentissage en profondeur méthode dans laquelle certains paramètres conditionnels sont mis en place .
   • Dans CGAN, un paramètre supplémentaire « y » est ajouté au générateur pour générer les données correspondantes.
   • Des étiquettes sont également placées dans l'entrée du discriminateur afin que le discriminateur puisse aider à distinguer les données réelles des fausses données générées.
3. GAN convolutif profond (DCGAN) : DCGAN est l’une des implémentations les plus populaires et aussi les plus réussies du GAN. Cela est composé de ConvNets au lieu de perceptrons multicouches .
   • Les ConvNets sont implémentés sans pooling maximum, qui est en fait remplacé par une foulée convolutive.
   • De plus, les couches ne sont pas entièrement connectées.
4. Pyramide Laplacienne GAN (LAPGAN) : Le Pyramide laplacienne est une représentation d'image linéaire inversible composée d'un ensemble d'images passe-bande, espacées d'une octave, plus un résidu basse fréquence.
   • Cette approche utilise plusieurs nombres de réseaux générateurs et discriminateurs et différents niveaux de la Pyramide Laplacienne.
   • Cette approche est principalement utilisée car elle produit des images de très haute qualité. L'image est d'abord sous-échantillonnée à chaque couche de la pyramide, puis elle est à nouveau mise à l'échelle à chaque couche lors d'un passage en arrière où l'image acquiert du bruit du GAN conditionnel au niveau de ces couches jusqu'à ce qu'elle atteigne sa taille d'origine.
5. GAN super résolution (SRGAN) : SRGAN comme son nom l'indique, c'est une façon de concevoir un GAN dans lequel un réseau neuronal profond est utilisé avec un réseau contradictoire afin de produire des images à plus haute résolution. Ce type de GAN est particulièrement utile pour mettre à l’échelle de manière optimale les images natives à basse résolution afin d’améliorer leurs détails en minimisant les erreurs.

Architecture des GAN

Un réseau contradictoire génératif (GAN) est composé de deux parties principales, qui sont le générateur et le discriminateur.

Modèle de générateur

Le modèle générateur est un élément clé responsable de la création de données fraîches et précises dans un réseau contradictoire génératif (GAN). Le générateur prend du bruit aléatoire en entrée et le convertit en échantillons de données complexes, tels que du texte ou des images. Il est communément décrit comme un réseau neuronal profond.

La distribution sous-jacente des données de formation est capturée par des couches de paramètres apprenables lors de sa conception via la formation. Le générateur ajuste sa sortie pour produire des échantillons qui imitent fidèlement les données réelles lors de leur entraînement en utilisant la rétropropagation pour affiner ses paramètres.

La capacité du générateur à générer des échantillons variés et de haute qualité qui peuvent tromper le discriminateur est ce qui fait son succès.

Perte du générateur

L’objectif du générateur d’un GAN est de produire des échantillons synthétiques suffisamment réalistes pour tromper le discriminateur. Le générateur y parvient en minimisant sa fonction de perteJ_G​. La perte est minimisée lorsque la probabilité logarithmique est maximisée, c'est-à-dire lorsque le discriminateur est hautement susceptible de classer les échantillons générés comme réels. L’équation suivante est donnée ci-dessous :

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

• J_G mesurer dans quelle mesure le générateur trompe le discriminateur.
• enregistrerD(G(z_i) )représente la probabilité logarithmique que le discriminateur soit correct pour les échantillons générés.
• Le générateur vise à minimiser cette perte, en favorisant la production d'échantillons que le discriminateur classe comme réels.(log D(G(z_i)), proche de 1.

Modèle discriminateur

Un réseau neuronal artificiel appelé modèle discriminateur est utilisé dans les réseaux contradictoires génératifs (GAN) pour différencier les entrées générées et réelles. En évaluant les échantillons d'entrée et en attribuant une probabilité d'authenticité, le discriminateur fonctionne comme un classificateur binaire.

Au fil du temps, le discriminateur apprend à faire la différence entre les données authentiques de l'ensemble de données et les échantillons artificiels créés par le générateur. Cela lui permet d’affiner progressivement ses paramètres et d’augmenter son niveau de compétence.

Couches convolutives ou des structures pertinentes pour d'autres modalités sont généralement utilisées dans son architecture lorsqu'il s'agit de données d'image. Maximiser la capacité du discriminateur à identifier avec précision les échantillons générés comme frauduleux et les échantillons réels comme authentiques est l’objectif de la procédure de formation contradictoire. Le discriminateur devient de plus en plus discriminant en raison de l’interaction du générateur et du discriminateur, ce qui aide le GAN à produire globalement des données synthétiques extrêmement réalistes.

Perte du discriminateur

Le discriminateur réduit la probabilité logarithmique négative de classer correctement les échantillons produits et réels. Cette perte incite le discriminateur à catégoriser avec précision les échantillons générés en échantillons faux et réels avec l'équation suivante :
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_Dévalue la capacité du discriminateur à discerner entre les échantillons produits et réels.
• La probabilité logarithmique que le discriminateur catégorise avec précision les données réelles est représentée parlogD(x_i).
• La probabilité logarithmique que le discriminateur catégorise correctement les échantillons générés comme faux est représentée parlog⁡(1-D(G(z_i))).
• Le discriminateur vise à réduire cette perte en identifiant avec précision les échantillons artificiels et réels.

Perte MinMax

Dans un réseau contradictoire génératif (GAN), la formule de perte minimax est fournie par :

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)))]
Où,

• G est le réseau générateur et D est le réseau discriminateur
• Échantillons de données réels obtenus à partir de la véritable distribution des donnéesp_{data}(x) sont représentés par x.
• Bruit aléatoire échantillonné à partir d'une distribution précédentep_z(z) (généralement une distribution normale ou uniforme) est représentée par z.
• D(x) représente la probabilité du discriminateur d’identifier correctement les données réelles comme étant réelles.
• D(G(z)) est la probabilité que le discriminateur identifie les données générées provenant du générateur comme étant authentiques.

Comment fonctionne un GAN ?

Les étapes impliquées dans le fonctionnement d'un GAN :

1. Initialisation : Deux réseaux de neurones sont créés : un Générateur (G) et un Discriminateur (D).
   • G est chargé de créer de nouvelles données, comme des images ou du texte, qui ressemblent beaucoup à des données réelles.
   • D agit comme un critique, essayant de faire la distinction entre les données réelles (provenant d'un ensemble de données d'entraînement) et les données générées par G.
2. Premier mouvement du générateur : G prend un vecteur de bruit aléatoire en entrée. Ce vecteur de bruit contient des valeurs aléatoires et sert de point de départ au processus de création de G. En utilisant ses couches internes et ses modèles appris, G transforme le vecteur de bruit en un nouvel échantillon de données, comme une image générée.
3. Le tour du discriminateur : D reçoit deux types d'entrées :
   • Échantillons de données réelles de l'ensemble de données d'entraînement.
   • Les échantillons de données générés par G à l’étape précédente. Le travail de D consiste à analyser chaque entrée et à déterminer s’il s’agit de données réelles ou de quelque chose que G a concocté. Il génère un score de probabilité compris entre 0 et 1. Un score de 1 indique que les données sont probablement réelles, et 0 suggère qu'elles sont fausses.
4. Le processus d'apprentissage : Maintenant, la partie contradictoire entre en jeu :
   • Si D identifie correctement les données réelles comme réelles (score proche de 1) et les données générées comme fausses (score proche de 0), G et D sont tous deux récompensés dans une faible mesure. C’est parce qu’ils font tous les deux bien leur travail.
   • Cependant, la clé est de s’améliorer continuellement. Si D identifie systématiquement tout correctement, il n’apprendra pas grand-chose. Le but est donc que G finisse par tromper D.
5. Amélioration du générateur :
   • Lorsque D qualifie par erreur la création de G de réelle (score proche de 1), c’est le signe que G est sur la bonne voie. Dans ce cas, G reçoit une mise à jour positive significative, tandis que D reçoit une pénalité pour avoir été trompé.
   • Ces retours aident G à améliorer son processus de génération pour créer des données plus réalistes.
6. Adaptation du discriminateur :
   • A l’inverse, si D identifie correctement les fausses données de G (score proche de 0), mais que G ne reçoit aucune récompense, D est encore renforcé dans ses capacités de discrimination.
   • Ce duel permanent entre G et D affine les deux réseaux au fil du temps.

Au fur et à mesure que l'entraînement progresse, G parvient à mieux générer des données réalistes, ce qui rend plus difficile pour D de faire la différence. Idéalement, G devient si habile que D ne peut pas distinguer de manière fiable les données réelles des fausses données. À ce stade, G est considéré comme bien formé et peut être utilisé pour générer de nouveaux échantillons de données réalistes.

tableau dynamique java

Mise en œuvre du réseau contradictoire génératif (GAN)

Nous suivrons et comprendrons les étapes pour comprendre comment le GAN est implémenté :

Étape 1 : Importer les bibliothèques requises

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.>