TUTTAVIA (Generative Adversarial Network) rappresenta un approccio all'avanguardia alla modellazione generativa nell'ambito del deep learning, spesso sfruttando architetture come reti neurali convoluzionali . L’obiettivo della modellazione generativa è identificare in modo autonomo i modelli nei dati di input, consentendo al modello di produrre nuovi esempi che assomiglino in modo fattibile al set di dati originale.

Questo articolo copre tutto ciò che devi sapere GAN, l'architettura GAN, il funzionamento di GAN e i tipi di modelli GAN e così via.

Tabella dei contenuti

• Cos’è una rete avversaria generativa?
• Tipi di GAN
• Architettura dei GAN
• Come funziona un GAN?
• Implementazione di un GAN
• Applicazione delle reti generative avversarie (GAN)
• Vantaggi del GAN
• Svantaggi del GAN
• GAN (Generative Adversarial Network) - Domande frequenti

Cos’è una rete avversaria generativa?

Le Generative Adversarial Networks (GAN) sono una potente classe di reti neurali utilizzate per un apprendimento non supervisionato . I GAN sono composti da due reti neurali , un discriminatore e un generatore. Usano la formazione contraddittoria per produrre dati artificiali identici ai dati reali.

• Il generatore tenta di ingannare il discriminatore, che ha il compito di distinguere accuratamente tra dati prodotti e dati autentici, producendo campioni di rumore casuali.
• Come risultato di questa interazione competitiva, vengono prodotti campioni realistici e di alta qualità, che spingono entrambe le reti verso il progresso.
• I GAN si stanno rivelando strumenti di intelligenza artificiale altamente versatili, come evidenziato dal loro ampio utilizzo nella sintesi di immagini, nel trasferimento di stili e nella sintesi da testo a immagine.
• Hanno anche rivoluzionato la modellazione generativa.

Attraverso la formazione contraddittoria, questi modelli si impegnano in un’interazione competitiva finché il generatore non diventa abile nel creare campioni realistici, ingannando il discriminatore circa la metà delle volte.

Le reti generative avversarie (GAN) possono essere suddivise in tre parti:

• generativo: Imparare un modello generativo, che descrive come i dati vengono generati in termini di un modello probabilistico.
• Avversario: La parola contraddittorio si riferisce al mettere una cosa contro un'altra. Ciò significa che, nel contesto dei GAN, il risultato generativo viene confrontato con le immagini reali nel set di dati. Un meccanismo noto come discriminatore viene utilizzato per applicare un modello che tenta di distinguere tra immagini reali e false.
• Reti: Utilizzare le reti neurali profonde come algoritmi di intelligenza artificiale (AI) per scopi di formazione.

Tipi di GAN

1. Vaniglia GAN: Questo è il tipo più semplice di GAN. Qui, il Generatore e il Discriminatore sono semplici e basilari percettroni multistrato . In Vanilla GAN, l'algoritmo è davvero semplice, cerca di ottimizzare l'equazione matematica utilizzando discesa del gradiente stocastico.
2. GAN condizionale (CGAN): CGAN può essere descritto come a apprendimento approfondito metodo in cui vengono messi in atto alcuni parametri condizionali .
   • In CGAN, un parametro aggiuntivo 'y' viene aggiunto al generatore per generare i dati corrispondenti.
   • Le etichette vengono inoltre inserite nell'input del Discriminatore affinché il Discriminatore possa aiutare a distinguere i dati reali dai dati falsi generati.
3. GAN convoluzionale profondo (DCGAN): DCGAN è una delle implementazioni GAN più popolari e anche di maggior successo. È composto da ConvNet al posto di percettroni multistrato .
   • Le ConvNet sono implementate senza il max pooling, che è infatti sostituito dal passo convoluzionale.
   • Inoltre, gli strati non sono completamente collegati.
4. Piramide Laplaciana GAN (LAPGAN): IL Piramide laplaciana è una rappresentazione di immagine lineare invertibile costituita da un insieme di immagini passa-banda, distanziate di un'ottava, più un residuo a bassa frequenza.
   • Questo approccio utilizza più numeri di reti Generatore e Discriminatore e diversi livelli della Piramide Laplaciana.
   • Questo approccio viene utilizzato principalmente perché produce immagini di altissima qualità. L'immagine viene inizialmente sottoposta a downsampling su ogni strato della piramide e poi nuovamente ingrandita su ogni strato in un passaggio all'indietro in cui l'immagine acquisisce del rumore dal GAN ​​condizionale su questi strati fino a raggiungere la sua dimensione originale.
5. GAN a super risoluzione (SRGAN): SRGAN come suggerisce il nome è un modo di progettare un GAN in cui a rete neurale profonda viene utilizzato insieme a una rete avversaria per produrre immagini ad alta risoluzione. Questo tipo di GAN è particolarmente utile per eseguire l'upscaling ottimale delle immagini native a bassa risoluzione per migliorarne i dettagli riducendo al minimo gli errori.

Architettura dei GAN

Una rete generativa contraddittoria (GAN) è composta da due parti principali, che sono il generatore e il discriminatore.

Modello del generatore

Un elemento chiave responsabile della creazione di dati nuovi e accurati in una rete generativa avversaria (GAN) è il modello del generatore. Il generatore prende il rumore casuale come input e lo converte in campioni di dati complessi, come testo o immagini. È comunemente raffigurato come una rete neurale profonda.

La distribuzione sottostante dei dati di addestramento viene catturata da strati di parametri apprendibili nella sua progettazione attraverso la formazione. Il generatore regola il suo output per produrre campioni che imitano fedelmente i dati reali mentre viene addestrato utilizzando la backpropagation per ottimizzare i suoi parametri.

La capacità del generatore di generare campioni vari e di alta qualità in grado di ingannare il discriminatore è ciò che ne garantisce il successo.

Perdita del generatore

L'obiettivo del generatore in un GAN è produrre campioni sintetici sufficientemente realistici da ingannare il discriminatore. Il generatore raggiunge questo obiettivo riducendo al minimo la sua funzione di perditaJ_G​. La perdita è minimizzata quando la probabilità logaritmica è massimizzata, cioè quando è altamente probabile che il discriminatore classifichi i campioni generati come reali. Di seguito è riportata la seguente equazione:

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

• J_G misurare quanto bene il generatore inganna il discriminatore.
• tronco d'alberoD(G(z_i) )rappresenta la probabilità logaritmica che il discriminatore sia corretto per i campioni generati.
• Il generatore mira a minimizzare questa perdita, favorendo la produzione di campioni che il discriminatore classifica come reali(log D(G(z_i)), vicino a 1.

Modello discriminatore

Una rete neurale artificiale chiamata modello discriminatore viene utilizzata nelle reti generative avversarie (GAN) per distinguere tra input generato ed effettivo. Valutando i campioni di input e assegnando la probabilità di autenticità, il discriminatore funziona come un classificatore binario.

Nel tempo, il discriminatore impara a distinguere tra dati autentici dal set di dati e campioni artificiali creati dal generatore. Ciò gli consente di affinare progressivamente i suoi parametri e aumentare il suo livello di competenza.

Strati convoluzionali oppure strutture pertinenti per altre modalità vengono solitamente utilizzate nella sua architettura quando si tratta di dati di immagine. Massimizzare la capacità del discriminatore di identificare accuratamente i campioni generati come fraudolenti e i campioni reali come autentici è lo scopo della procedura di formazione contraddittoria. Il discriminatore diventa sempre più discriminante come risultato dell’interazione tra il generatore e il discriminatore, il che aiuta il GAN ​​a produrre nel complesso dati sintetici dall’aspetto estremamente realistico.

Perdita del discriminante

Il discriminatore riduce la probabilità del log negativo di classificare correttamente sia i campioni prodotti che quelli reali. Questa perdita incentiva il discriminatore a classificare accuratamente i campioni generati come campioni falsi e reali con la seguente equazione:
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_Dvaluta la capacità del discriminatore di discernere tra campioni prodotti e campioni reali.
• La probabilità logaritmica che il discriminatore classifichi accuratamente i dati reali è rappresentata dalogD(x_i).
• La probabilità logaritmica che il discriminatore classifichi correttamente i campioni generati come falsi è rappresentata dalog⁡(1-D(G(z_i))).
• Il discriminatore mira a ridurre questa perdita identificando accuratamente campioni artificiali e reali.

Perdita MinMax

In una Generative Adversarial Network (GAN), la formula della perdita minimax è fornita da:

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)))]
Dove,

• G è la rete del generatore e D è la rete del discriminatore
• Campioni di dati effettivi ottenuti dalla distribuzione dei dati realip_{data}(x) sono rappresentati da x.
• Rumore casuale campionato da una distribuzione precedentep_z(z) (di solito una distribuzione normale o uniforme) è rappresentata da z.
• D(x) rappresenta la probabilità del discriminatore di identificare correttamente i dati reali come reali.
• D(G(z)) è la probabilità che il discriminatore identifichi come autentici i dati generati provenienti dal generatore.

Come funziona un GAN?

I passaggi coinvolti nel funzionamento di un GAN:

1. Inizializzazione: Vengono create due reti neurali: un Generatore (G) e un Discriminatore (D).
   • G ha il compito di creare nuovi dati, come immagini o testo, che assomiglino molto ai dati reali.
   • D agisce da critico, cercando di distinguere tra dati reali (da un dataset di training) e dati generati da G.
2. Prima mossa del generatore: G prende come input un vettore di rumore casuale. Questo vettore di rumore contiene valori casuali e funge da punto di partenza per il processo di creazione di G. Utilizzando i suoi livelli interni e i modelli appresi, G trasforma il vettore del rumore in un nuovo campione di dati, come un'immagine generata.
3. Turno del Discriminatore: D riceve due tipi di input:
   • Campioni di dati reali dal set di dati di addestramento.
   • I campioni di dati generati da G nel passaggio precedente. Il compito di D è analizzare ogni input e determinare se si tratta di dati reali o di qualcosa che G ha inventato. Restituisce un punteggio di probabilità compreso tra 0 e 1. Un punteggio pari a 1 indica che i dati sono probabilmente reali e 0 suggerisce che sono falsi.
4. Il processo di apprendimento: Ora entra in gioco la parte contraddittoria:
   • Se D identifica correttamente i dati reali come reali (punteggio vicino a 1) e i dati generati come falsi (punteggio vicino a 0), sia G che D vengono ricompensati in piccola misura. Questo perché entrambi stanno facendo bene il loro lavoro.
   • La chiave, però, è migliorare continuamente. Se D identifica costantemente tutto correttamente, non imparerà molto. Quindi, l’obiettivo è che G alla fine inganni D.
5. Miglioramento del generatore:
   • Quando D etichetta erroneamente la creazione di G come reale (punteggio vicino a 1), è segno che G è sulla strada giusta. In questo caso G riceve un significativo aggiornamento positivo, mentre D riceve una penalità per essere stato ingannato.
   • Questo feedback aiuta G a migliorare il processo di generazione per creare dati più realistici.
6. Adattamento del discriminatore:
   • Al contrario, se D identifica correttamente i dati falsi di G (punteggio vicino a 0), ma G non riceve alcuna ricompensa, D risulta ulteriormente rafforzata nelle sue capacità discriminative.
   • Questo duello in corso tra G e D affina entrambe le reti nel tempo.

Con il progredire dell'addestramento, G migliora nel generare dati realistici, rendendo più difficile per D notare la differenza. Idealmente, G diventa così abile che D non riesce a distinguere in modo affidabile i dati reali da quelli falsi. A questo punto, G è considerato ben addestrato e può essere utilizzato per generare campioni di dati nuovi e realistici.

funzionalità Java8

Implementazione della rete generativa avversaria (GAN)

Seguiremo e comprenderemo i passaggi per capire come viene implementato il GAN:

Passaggio 1: importazione delle librerie richieste

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