VŠAK (Generative Adversarial Network) predstavuje špičkový prístup ku generatívnemu modelovaniu v rámci hlbokého učenia, pričom často využíva architektúry ako napr. konvolučné neurónové siete . Cieľom generatívneho modelovania je autonómne identifikovať vzory vo vstupných údajoch, čo umožňuje modelu vytvárať nové príklady, ktoré sa reálne podobajú pôvodnému súboru údajov.

Tento článok obsahuje všetko, o čom potrebujete vedieť GAN, architektúra GAN, fungovanie GAN a typy modelov GAN atď.

Obsah

• Čo je generatívna adverzná sieť?
• Typy GAN
• Architektúra GAN
• Ako funguje GAN?
• Implementácia GAN
• Aplikácia generatívnych adverzných sietí (GAN)
• Výhody GAN
• Nevýhody GAN
• GAN (Generative Adversarial Network) – často kladené otázky

Čo je generatívna adverzná sieť?

Generative Adversarial Networks (GAN) sú výkonnou triedou neurónových sietí, ktoré sa používajú na učenie bez dozoru . GAN sa skladajú z dvoch neurálne siete , diskriminátor a generátor. Na výrobu umelých údajov, ktoré sú identické so skutočnými údajmi, používajú tréning protivníkov.

• Generátor sa pokúša oklamať diskriminátora, ktorý má za úlohu presne rozlišovať medzi produkovanými a skutočnými údajmi, vytváraním vzoriek náhodného šumu.
• Výsledkom tejto konkurenčnej interakcie, ktorá vedie obe siete k pokroku, sú realistické vzorky vysokej kvality.
• GAN sa ukazujú ako vysoko všestranné nástroje umelej inteligencie, o čom svedčí ich široké využitie pri syntéze obrázkov, prenose štýlov a syntéze textu na obrázok.
• Priniesli tiež revolúciu v generatívnom modelovaní.

Prostredníctvom tréningu protivníkov sa tieto modely zapájajú do konkurenčnej súhry, až kým sa generátor nestane zručným vo vytváraní realistických vzoriek, čím oklame diskriminátor približne polovicu času.

Generatívne adverzné siete (GAN) možno rozdeliť do troch častí:

• Generatívne: Naučiť sa generatívny model, ktorý popisuje, ako sa generujú údaje z hľadiska pravdepodobnostného modelu.
• Protivník: Slovo kontradiktórne sa týka postavenia jednej veci proti druhej. To znamená, že v kontexte GAN sa generatívny výsledok porovnáva so skutočnými obrázkami v súbore údajov. Mechanizmus známy ako diskriminátor sa používa na aplikáciu modelu, ktorý sa pokúša rozlíšiť medzi skutočnými a falošnými obrázkami.
• Siete: Použite hlboké neurónové siete ako algoritmy umelej inteligencie (AI) na tréningové účely.

Typy GAN

1. Vanilkový GAN: Toto je najjednoduchší typ GAN. Tu sú Generátor a Diskriminátor jednoduchý základ viacvrstvové perceptróny . Vo vanilla GAN je algoritmus skutočne jednoduchý, snaží sa optimalizovať pomocou matematickej rovnice stochastický gradientový zostup.
2. Podmienený GAN (CGAN): CGAN možno opísať ako a hlboké učenie spôsob, v ktorom zaviedli sa niektoré podmienené parametre .
   • V CGAN sa do generátora pridáva ďalší parameter „y“ na generovanie zodpovedajúcich údajov.
   • Štítky sa tiež vkladajú do vstupu pre diskriminátora, aby diskriminátor pomohol rozlíšiť skutočné údaje od falošných vygenerovaných údajov.
3. Deep Convolutional GAN ​​(DCGAN): DCGAN je jednou z najpopulárnejších a zároveň najúspešnejších implementácií GAN. Skladá sa z ConvNets namiesto viacvrstvové perceptróny .
   • ConvNets sú implementované bez maximálneho združovania, čo je v skutočnosti nahradené konvolučným krokom.
   • Vrstvy tiež nie sú úplne spojené.
4. Laplaciánska pyramída GAN (LAPGAN): The Laplacia pyramída je lineárna invertibilná obrazová reprezentácia pozostávajúca zo súboru pásmových priepustov, vzdialených od seba oktávu, plus nízkofrekvenčný reziduálny.
   • Tento prístup používa viacero čísel sietí generátorov a diskriminátorov a rôzne úrovne Laplaciovej pyramídy.
   • Tento prístup sa používa hlavne preto, že vytvára veľmi kvalitné obrázky. Obraz sa najprv prevzorkuje na každej vrstve pyramídy a potom sa znova prevzorkuje na každej vrstve v spätnom prechode, kde obraz získa určitý šum z podmieneného GAN v týchto vrstvách, kým nedosiahne svoju pôvodnú veľkosť.
5. Super rozlíšenie GAN (SRGAN): SRGAN ako už názov napovedá, ide o spôsob navrhovania GAN, v ktorom a hlboká neurónová sieť sa používa spolu so sieťou protivníkov na vytváranie obrázkov s vyšším rozlíšením. Tento typ GAN je obzvlášť užitočný pri optimálnom zvyšovaní veľkosti natívnych obrázkov s nízkym rozlíšením, aby sa zlepšili ich detaily a zároveň sa minimalizovali chyby.

Architektúra GAN

Generative Adversarial Network (GAN) sa skladá z dvoch primárnych častí, ktorými sú generátor a diskriminátor.

Model generátora

Kľúčovým prvkom zodpovedným za vytváranie čerstvých a presných údajov v sieti Generative Adversarial Network (GAN) je model generátora. Generátor berie ako vstup náhodný šum a konvertuje ho na komplexné dátové vzorky, ako je text alebo obrázky. Bežne sa zobrazuje ako hlboká neurónová sieť.

Základná distribúcia tréningových údajov je zachytená vrstvami naučiteľných parametrov pri ich návrhu prostredníctvom tréningu. Generátor prispôsobuje svoj výstup tak, aby produkoval vzorky, ktoré presne napodobňujú skutočné údaje, keď sú trénované pomocou spätného šírenia na jemné doladenie jeho parametrov.

Schopnosť generátora generovať vysokokvalitné, rôznorodé vzorky, ktoré môžu oklamať diskriminátor, je to, čo robí to úspešným.

Strata generátora

Cieľom generátora v GAN je produkovať syntetické vzorky, ktoré sú dostatočne realistické na to, aby oklamali diskriminátor. Generátor to dosiahne minimalizáciou svojej stratovej funkcieJ_G. Strata je minimalizovaná, keď je logaritmická pravdepodobnosť maximalizovaná, t.j. keď je vysoko pravdepodobné, že diskriminátor klasifikuje generované vzorky ako skutočné. Nasledujúca rovnica je uvedená nižšie:

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

• J_G zmerajte, ako dobre generátor oklame diskriminátor.
• logD(G(z_i) )predstavuje logaritmickú pravdepodobnosť, že diskriminátor je správny pre generované vzorky.
• Cieľom generátora je minimalizovať túto stratu a podporovať produkciu vzoriek, ktoré diskriminátor klasifikuje ako skutočné(log D(G(z_i)), blízko 1.

Model diskriminátora

Umelá neurónová sieť nazývaná diskriminačný model sa používa v generatívnych adverzných sieťach (GAN) na rozlíšenie medzi generovaným a skutočným vstupom. Vyhodnotením vstupných vzoriek a pridelením pravdepodobnosti pravosti funguje diskriminátor ako binárny klasifikátor.

Postupom času sa diskriminátor naučí rozlišovať medzi skutočnými údajmi zo súboru údajov a umelými vzorkami vytvorenými generátorom. To mu umožňuje postupne zdokonaľovať svoje parametre a zvyšovať úroveň svojej odbornosti.

Konvolučné vrstvy alebo príslušné štruktúry pre iné modality sa zvyčajne používajú v jeho architektúre pri práci s obrazovými dátami. Cieľom tréningového postupu protivníka je maximalizovať schopnosť diskriminátora presne identifikovať generované vzorky ako podvodné a skutočné vzorky ako autentické. Diskriminátor sa stáva čoraz viac diskriminačným v dôsledku interakcie generátora a diskriminátora, čo pomáha GAN produkovať celkovo extrémne realisticky vyzerajúce syntetické údaje.

Strata diskriminátora

Diskriminátor znižuje negatívnu logaritmickú pravdepodobnosť správnej klasifikácie vyrobených aj skutočných vzoriek. Táto strata stimuluje diskriminátor, aby presne kategorizoval generované vzorky ako falošné a skutočné vzorky podľa nasledujúcej rovnice:
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_Dposudzuje schopnosť diskriminátora rozlíšiť medzi vyrobenými a skutočnými vzorkami.
• Pravdepodobnosť logaritmu, že diskriminátor presne kategorizuje skutočné údaje, predstavujelogD(x_i).
• Log pravdepodobnosť, že diskriminátor správne kategorizuje vygenerované vzorky ako falošné, predstavujelog⁡(1-D(G(z_i))).
• Diskriminátor má za cieľ znížiť túto stratu presnou identifikáciou umelých a skutočných vzoriek.

MinMax Strata

V Generative Adversarial Network (GAN) je vzorec pre minimálnu stratu poskytovaný:

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

• G je sieť generátora a D je sieť diskriminátora
• Skutočné vzorky údajov získané z distribúcie skutočných údajovp_{data}(x) sú reprezentované x.
• Náhodný šum vzorkovaný z predchádzajúcej distribúciep_z(z) (zvyčajne normálne alebo rovnomerné rozdelenie) je reprezentované z.
• D(x) predstavuje pravdepodobnosť, že diskriminátor správne identifikuje skutočné údaje ako skutočné.
• D(G(z)) je pravdepodobnosť, že diskriminátor identifikuje generované dáta pochádzajúce z generátora ako autentické.

Ako funguje GAN?

Kroky týkajúce sa fungovania siete GAN:

1. Inicializácia: Sú vytvorené dve neurónové siete: Generátor (G) a Diskriminátor (D).
   • G má za úlohu vytvárať nové údaje, ako sú obrázky alebo text, ktoré sa veľmi podobajú skutočným údajom.
   • D pôsobí ako kritik a snaží sa rozlíšiť medzi skutočnými údajmi (z tréningového súboru údajov) a údajmi generovanými G.
2. Prvý ťah generátora: G berie ako vstup vektor náhodného šumu. Tento vektor šumu obsahuje náhodné hodnoty a funguje ako východiskový bod pre proces vytvárania G. Pomocou svojich vnútorných vrstiev a naučených vzorov G transformuje vektor šumu na novú vzorku údajov, ako je vygenerovaný obrázok.
3. Na rade je diskriminátor: D prijíma dva druhy vstupov:
   • Reálne vzorky údajov z tréningového súboru údajov.
   • Vzorky údajov vygenerované G v predchádzajúcom kroku. Úlohou D je analyzovať každý vstup a určiť, či ide o skutočné údaje alebo niečo, čo G uvaril. Výsledkom je skóre pravdepodobnosti medzi 0 a 1. Skóre 1 znamená, že údaje sú pravdepodobne skutočné, a 0 znamená, že sú falošné.
4. Proces učenia: Teraz prichádza protistrana:
   • Ak D správne identifikuje skutočné údaje ako skutočné (skóre blízke 1) a generované údaje ako falošné (skóre blízke 0), G aj D sú v malej miere odmenené. Je to preto, že obaja robia svoju prácu dobre.
   • Základom je však neustále sa zlepšovať. Ak D dôsledne identifikuje všetko správne, veľa sa toho nenaučí. Takže cieľom je, aby G nakoniec oklamal D.
5. Vylepšenie generátora:
   • Keď D omylom označí výtvor G ako skutočný (skóre blízko 1), je to znamenie, že G je na správnej ceste. V tomto prípade dostane G významnú pozitívnu aktualizáciu, zatiaľ čo D dostane trest za oklamanie.
   • Táto spätná väzba pomáha G vylepšiť proces generovania a vytvárať realistickejšie údaje.
6. Adaptácia diskriminátora:
   • Naopak, ak D správne identifikuje falošné údaje G (skóre blízke 0), ale G nedostane žiadnu odmenu, D sa ďalej posilní vo svojich rozlišovacích schopnostiach.
   • Tento prebiehajúci súboj medzi G a D časom vylepšuje obe siete.

Ako tréning postupuje, G sa zlepšuje vo vytváraní realistických údajov, takže je pre D ťažšie rozoznať rozdiel. V ideálnom prípade sa G stane natoľko zdatným, že D nedokáže spoľahlivo rozlíšiť skutočné od falošných údajov. V tomto bode sa G považuje za dobre vyškolený a možno ho použiť na generovanie nových, realistických vzoriek údajov.

java získať aktuálny čas

Implementácia siete Generative Adversarial Network (GAN)

Budeme postupovať a porozumieť krokom, aby sme pochopili, ako sa implementuje GAN:

Krok 1: Import požadovaných knižníc

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