IN ORICE CAZ (Generative Adversarial Network) reprezintă o abordare de ultimă oră a modelării generative în cadrul învățării profunde, utilizând adesea arhitecturi precum rețele neuronale convoluționale . Scopul modelării generative este de a identifica în mod autonom modele în datele de intrare, permițând modelului să producă noi exemple care să semene fezabil cu setul de date original.

Acest articol acoperă tot ce trebuie să știți despre GAN, Arhitectura GAN, Funcționarea GAN și tipurile de modele GAN și așa mai departe.

Cuprins

• Ce este o rețea adversară generativă?
• Tipuri de GAN-uri
• Arhitectura GAN-urilor
• Cum funcționează un GAN?
• Implementarea unui GAN
• Aplicarea rețelelor generative adversare (GAN)
• Avantajele GAN
• Dezavantajele GAN
• GAN (Generative Adversarial Network) - Întrebări frecvente

Ce este o rețea adversară generativă?

Rețelele adverse generative (GAN) sunt o clasă puternică de rețele neuronale care sunt utilizate pentru un învăţare nesupravegheată . GAN-urile sunt formate din două rețele neuronale , un discriminator și un generator. Ei folosesc antrenamentul adversar pentru a produce date artificiale care sunt identice cu datele reale.

• Generatorul încearcă să-l păcălească pe Discriminator, care are sarcina de a distinge cu precizie între datele produse și cele reale, prin producerea de mostre aleatorii de zgomot.
• Eșantioane realiste, de înaltă calitate, sunt produse ca rezultat al acestei interacțiuni competitive, care conduce ambele rețele spre avansare.
• GAN-urile se dovedesc a fi instrumente de inteligență artificială extrem de versatile, așa cum demonstrează utilizarea lor extinsă în sinteza imaginilor, transferul stilului și sinteza text-la-imagine.
• De asemenea, au revoluționat modelarea generativă.

Prin antrenament adversar, aceste modele se angajează într-o interacțiune competitivă până când generatorul devine abil să creeze mostre realiste, păcălindu-l pe discriminator aproximativ jumătate din timp.

Rețelele generative adversare (GAN) pot fi împărțite în trei părți:

• generativ: Pentru a învăța un model generativ, care descrie modul în care datele sunt generate în termeni de model probabilistic.
• adversar: Cuvântul adversar se referă la a pune un lucru împotriva altuia. Aceasta înseamnă că, în contextul GAN-urilor, rezultatul generativ este comparat cu imaginile reale din setul de date. Un mecanism cunoscut sub numele de discriminator este utilizat pentru a aplica un model care încearcă să facă distincția între imaginile reale și cele false.
• Rețele: Utilizați rețele neuronale profunde ca algoritmi de inteligență artificială (AI) în scopuri de antrenament.

Tipuri de GAN-uri

1. Vanilie GAN: Acesta este cel mai simplu tip de GAN. Aici, Generatorul și Discriminatorul sunt simple un element de bază perceptroni multistrat . În vanilla GAN, algoritmul este foarte simplu, încearcă să optimizeze ecuația matematică folosind coborâre a gradientului stocastic.
2. GAN condiționat (CGAN): CGAN poate fi descris ca a invatare profunda metoda prin care se pun în aplicare unii parametri condiționali .
   • În CGAN, un parametru suplimentar „y” este adăugat la Generator pentru generarea datelor corespunzătoare.
   • Etichetele sunt, de asemenea, introduse în intrarea către Discriminator, pentru ca acesta să ajute să distingă datele reale de datele false generate.
3. GAN convoluțional profund (DCGAN): DCGAN este una dintre cele mai populare și, de asemenea, cele mai de succes implementări ale GAN. Este compus din ConvNets in locul perceptroni multistrat .
   • ConvNet-urile sunt implementate fără pooling maxim, care este de fapt înlocuit cu pasul convoluțional.
   • De asemenea, straturile nu sunt complet conectate.
4. Piramida Laplaciană GAN (LAPGAN): The Piramida laplaciană este o reprezentare de imagine liniară inversabilă constând dintr-un set de imagini trece-bandă, distanțate la o octavă, plus un rezidual de joasă frecvență.
   • Această abordare folosește mai multe numere de rețele generatoare și discriminatoare și diferite niveluri ale piramidei laplaciene.
   • Această abordare este utilizată în principal deoarece produce imagini de foarte înaltă calitate. Imaginea este eșantionată mai întâi la fiecare strat al piramidei și apoi este din nou mărită la fiecare strat într-o trecere înapoi, unde imaginea capătă zgomot de la GAN condiționat la aceste straturi până când atinge dimensiunea inițială.
5. Super Resolution GAN (SRGAN): SRGAN după cum sugerează și numele este o modalitate de a proiecta un GAN în care a rețea neuronală profundă este utilizat împreună cu o rețea adversară pentru a produce imagini de rezoluție mai mare. Acest tip de GAN este deosebit de util în creșterea optimă a imaginilor native cu rezoluție scăzută pentru a le îmbunătăți detaliile, minimizând erorile în timp ce faceți acest lucru.

Arhitectura GAN-urilor

O rețea generativă adversară (GAN) este compusă din două părți principale, care sunt generatorul și discriminatorul.

Modelul generatorului

Un element cheie responsabil pentru crearea de date proaspete și precise într-o rețea generativă adversă (GAN) este modelul generator. Generatorul preia zgomot aleatoriu ca intrare și îl convertește în eșantioane de date complexe, cum ar fi text sau imagini. Este descris în mod obișnuit ca o rețea neuronală profundă.

Distribuția de bază a datelor de antrenament este capturată de straturi de parametri învățați în proiectarea sa prin antrenament. Generatorul își ajustează ieșirea pentru a produce eșantioane care imită îndeaproape datele reale pe măsură ce este antrenat, utilizând retropropagarea pentru a-și regla fin parametrii.

Capacitatea generatorului de a genera mostre de înaltă calitate, variate, care pot păcăli discriminatorul este ceea ce îl face să aibă succes.

Pierderea generatorului

Obiectivul generatorului într-un GAN este de a produce mostre sintetice suficient de realiste pentru a păcăli discriminatorul. Generatorul realizează acest lucru reducând la minimum funcția de pierdereJ_G. Pierderea este minimizată atunci când probabilitatea logarului este maximizată, adică atunci când discriminatorul este foarte probabil să clasifice eșantioanele generate ca fiind reale. Următoarea ecuație este dată mai jos:

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

• J_G măsurați cât de bine îl păcălește generatorul pe discriminator.
• ButurugaD(G(z_i) )reprezintă log probabilitatea ca discriminatorul să fie corect pentru probele generate.
• Generatorul urmărește să minimizeze această pierdere, încurajând producerea de mostre pe care discriminatorul le clasifică drept reale.(log D(G(z_i)), aproape de 1.

Modelul discriminator

O rețea neuronală artificială numită model discriminator este utilizată în rețelele generative adverse (GAN) pentru a diferenția între intrarea generată și cea reală. Prin evaluarea eșantioanelor de intrare și alocarea probabilității de autenticitate, discriminatorul funcționează ca un clasificator binar.

De-a lungul timpului, discriminatorul învață să facă diferența între datele autentice din setul de date și mostrele artificiale create de generator. Acest lucru îi permite să-și perfecționeze progresiv parametrii și să-și mărească nivelul de competență.

Straturi convoluționale sau structuri pertinente pentru alte modalități sunt de obicei folosite în arhitectura sa atunci când se ocupă cu date de imagine. Maximizarea capacității discriminatorului de a identifica cu precizie eșantioanele generate ca fiind frauduloase și eșantioanele reale ca autentice este scopul procedurii de formare contradictorie. Discriminatorul devine din ce în ce mai discriminator ca urmare a interacțiunii generatorului și discriminatorului, ceea ce ajută GAN să producă date sintetice cu aspect extrem de realist.

Pierderea discriminatorului

Discriminatorul reduce probabilitatea logului negativ de a clasifica corect atât eșantioanele produse, cât și cele reale. Această pierdere stimulează discriminatorul să clasifice cu precizie eșantioanele generate ca eșantioane false și reale cu următoarea ecuație:
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_Devaluează capacitatea discriminatorului de a discerne între eșantioanele produse și cele reale.
• Probabilitatea de jurnal ca discriminatorul să clasifice cu acuratețe datele reale este reprezentată delogD(x_i).
• Şansa logică ca discriminatorul să clasifice corect mostrele generate ca false este reprezentată delog⁡(1-D(G(z_i))).
• Discriminatorul urmărește să reducă această pierdere prin identificarea precisă a probelor artificiale și reale.

Pierdere MinMax

Într-o rețea generativă adversară (GAN), formula de pierdere minimax este furnizată de:

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

• G este rețeaua generatoare și este D este rețeaua discriminatoare
• Eșantioane de date reale obținute din distribuția reală a datelorp_{data}(x) sunt reprezentate prin x.
• Zgomot aleatoriu eșantionat dintr-o distribuție anterioarăp_z(z) (de obicei o distribuție normală sau uniformă) este reprezentată de z.
• D(x) reprezintă probabilitatea discriminatorului de a identifica corect datele reale ca fiind reale.
• D(G(z)) este probabilitatea ca discriminatorul să identifice datele generate care provin de la generator ca fiind autentice.

Cum funcționează un GAN?

Pașii implicați în modul în care funcționează un GAN:

1. Inițializare: Sunt create două rețele neuronale: un generator (G) și un discriminator (D).
   • G are sarcina de a crea date noi, cum ar fi imagini sau text, care seamănă foarte mult cu datele reale.
   • D acționează ca un critic, încercând să facă distincția între datele reale (de la un set de date de antrenament) și datele generate de G.
2. Prima mișcare a generatorului: G ia ca intrare un vector de zgomot aleatoriu. Acest vector de zgomot conține valori aleatorii și acționează ca punct de plecare pentru procesul de creare a lui G. Folosind straturile sale interne și modelele învățate, G transformă vectorul de zgomot într-o nouă mostră de date, ca o imagine generată.
3. Rândul discriminatorului: D primește două tipuri de intrări:
   • Mostre de date reale din setul de date de antrenament.
   • Eșantioanele de date generate de G în pasul anterior. Treaba lui D este să analizeze fiecare intrare și să determine dacă este vorba de date reale sau de ceva G gătit. Afișează un scor de probabilitate între 0 și 1. Un scor de 1 indică faptul că datele sunt probabil reale, iar 0 sugerează că sunt false.
4. Procesul de învățare: Acum, partea contradictorie intervine:
   • Dacă D identifică corect datele reale ca fiind reale (scor apropiat de 1) și datele generate ca false (scor aproape de 0), atât G cât și D sunt recompensați într-o mică măsură. Acest lucru se datorează faptului că amândoi își fac treaba bine.
   • Cu toate acestea, cheia este îmbunătățirea continuă. Dacă D identifică în mod constant totul corect, nu va învăța prea multe. Deci, scopul este ca G să-l păcălească în cele din urmă pe D.
5. Îmbunătățirea generatorului:
   • Când D etichetează în mod eronat creația lui G ca fiind reală (scor aproape de 1), este un semn că G este pe drumul cel bun. În acest caz, G primește o actualizare pozitivă semnificativă, în timp ce D primește o penalizare pentru că a fost păcălit.
   • Acest feedback îl ajută pe G să-și îmbunătățească procesul de generare pentru a crea date mai realiste.
6. Adaptarea discriminatorului:
   • În schimb, dacă D identifică corect datele false ale lui G (scor aproape de 0), dar G nu primește nicio recompensă, D este întărit și mai mult în abilitățile sale de discriminare.
   • Acest duel în curs între G și D rafinează ambele rețele în timp.

Pe măsură ce antrenamentul progresează, G devine mai bun la generarea de date realiste, ceea ce face mai greu pentru D să facă diferența. În mod ideal, G devine atât de abil încât D nu poate distinge în mod fiabil datele reale de cele false. În acest moment, G este considerat bine antrenat și poate fi folosit pentru a genera eșantioane de date noi, realiste.

sortați o listă de matrice

Implementarea rețelei generative adversare (GAN)

Vom urma și înțelege pașii pentru a înțelege cum este implementat GAN:

Pasul 1: Importul bibliotecilor necesare

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