VENDAR (Generative Adversarial Network) predstavlja vrhunski pristop k generativnemu modeliranju znotraj globokega učenja, ki pogosto uporablja arhitekture, kot je konvolucijske nevronske mreže . Cilj generativnega modeliranja je avtonomno identificirati vzorce v vhodnih podatkih, kar omogoča modelu, da ustvari nove primere, ki so izvedljivo podobni izvirnemu naboru podatkov.

Ta članek pokriva vse, kar morate vedeti GAN, arhitektura GAN, delovanje GAN in vrste modelov GAN itd.

Kazalo

• Kaj je generativno kontradiktorno omrežje?
• Vrste GAN
• Arhitektura GAN-ov
• Kako deluje GAN?
• Implementacija GAN
• Uporaba generativnih kontradiktornih omrežij (GAN)
• Prednosti GAN
• Slabosti GAN
• GAN (Generative Adversarial Network) – pogosta vprašanja

Kaj je generativno kontradiktorno omrežje?

Generativna kontradiktorna omrežja (GAN) so močan razred nevronskih mrež, ki se uporabljajo za nenadzorovano učenje . GAN so sestavljeni iz dveh nevronske mreže , diskriminator in generator. Uporabljajo kontradiktorno usposabljanje za izdelavo umetnih podatkov, ki so enaki dejanskim podatkom.

• Generator poskuša preslepiti diskriminator, ki je zadolžen za natančno razlikovanje med proizvedenimi in pristnimi podatki, tako da proizvede naključne vzorce šuma.
• Kot rezultat te konkurenčne interakcije nastanejo realistični, visokokakovostni vzorci, ki ženejo obe mreži k napredku.
• GAN se izkazujejo kot zelo vsestranska orodja umetne inteligence, kar dokazuje njihova obsežna uporaba pri sintezi slik, prenosu slogov in sintezi besedila v sliko.
• Revolucionirali so tudi generativno modeliranje.

Skozi kontradiktorni trening se ti modeli vključijo v tekmovalno medsebojno igro, dokler generator ne postane spreten pri ustvarjanju realističnih vzorcev, pri čemer diskriminatorja preslepi približno polovico časa.

Generativna kontradiktorna omrežja (GAN) lahko razdelimo na tri dele:

• Generativno: Naučiti se generativnega modela, ki opisuje, kako se podatki generirajo v smislu verjetnostnega modela.
• Nasprotno: Beseda kontradiktornost se nanaša na postavljanje ene stvari proti drugi. To pomeni, da se v kontekstu GAN generativni rezultat primerja z dejanskimi slikami v nizu podatkov. Mehanizem, znan kot diskriminator, se uporablja za uporabo modela, ki poskuša razlikovati med resničnimi in lažnimi slikami.
• Omrežja: Uporabite globoke nevronske mreže kot algoritme umetne inteligence (AI) za namene usposabljanja.

Vrste GAN

1. Vanilija GAN: To je najpreprostejša vrsta GAN. Tukaj sta Generator in Diskriminator preprosta in osnovna večplastni perceptroni . V vanilla GAN je algoritem zelo preprost, poskuša optimizirati matematično enačbo z stohastični gradientni spust.
2. Pogojni GAN (CGAN): CGAN lahko opišemo kot a globoko učenje metoda, pri kateri določeni so nekateri pogojni parametri .
   • V CGAN je Generatorju dodan dodaten parameter 'y' za generiranje ustreznih podatkov.
   • Oznake so prav tako vstavljene v vhod v diskriminator, da diskriminator pomaga razlikovati prave podatke od lažno ustvarjenih podatkov.
3. Deep Convolutional GAN ​​(DCGAN): DCGAN je ena najbolj priljubljenih in tudi najuspešnejših implementacij GAN. Sestavljen je iz ConvNets namesto večplastni perceptroni .
   • ConvNets se izvajajo brez maksimalnega združevanja, ki je dejansko nadomeščeno s konvolucijskim korakom.
   • Poleg tega plasti niso popolnoma povezane.
4. Laplačeva piramida GAN (LAPGAN): The Laplačeva piramida je linearna invertibilna predstavitev slike, sestavljena iz nabora pasovno prepustnih slik, ki so med seboj oddaljene za oktavo, in nizkofrekvenčnega ostanka.
   • Ta pristop uporablja več števil omrežij Generator in Discriminator in različne ravni Laplacijeve piramide.
   • Ta pristop se uporablja predvsem zato, ker ustvarja zelo kakovostne slike. Slika se najprej zniža na vsaki plasti piramide, nato pa se ponovno poveča na vsaki plasti v prehodu nazaj, kjer slika pridobi nekaj šuma iz pogojnega GAN na teh plasteh, dokler ne doseže prvotne velikosti.
5. Super ločljivost GAN (SRGAN): SRGAN kot že ime pove, je način oblikovanja GAN, v katerem a globoko nevronsko mrežo se uporablja skupaj z kontradiktornim omrežjem za izdelavo slik višje ločljivosti. Ta vrsta GAN je še posebej uporabna pri optimalnem povečanju izvornih slik nizke ločljivosti za izboljšanje njihovih podrobnosti in pri tem zmanjšanje napak.

Arhitektura GAN-ov

Generativno kontradiktorno omrežje (GAN) je sestavljeno iz dveh primarnih delov, ki sta generator in diskriminator.

Model generatorja

Ključni element, ki je odgovoren za ustvarjanje svežih, natančnih podatkov v Generative Adversarial Network (GAN), je generatorski model. Generator sprejme naključni šum kot vhod in ga pretvori v kompleksne vzorce podatkov, kot je besedilo ali slike. Običajno je prikazan kot globoka nevronska mreža.

Osnovna porazdelitev podatkov o usposabljanju je zajeta s plastmi naučljivih parametrov v njegovi zasnovi skozi usposabljanje. Generator prilagodi svoj izhod, da ustvari vzorce, ki natančno posnemajo resnične podatke, medtem ko se usposablja z uporabo povratnega širjenja za natančno nastavitev parametrov.

Generatorjeva zmožnost ustvarjanja visokokakovostnih, raznolikih vzorcev, ki lahko preslepijo diskriminatorja, je tisto, zaradi česar je uspešen.

Izguba generatorja

Cilj generatorja v GAN je ustvariti sintetične vzorce, ki so dovolj realistični, da preslepijo diskriminatorja. Generator to doseže tako, da minimizira svojo funkcijo izgubeJ_G. Izguba je čim manjša, ko je verjetnost dnevnika maksimirana, tj. ko je velika verjetnost, da bo diskriminator ustvarjene vzorce razvrstil kot resnične. Spodaj je podana naslednja enačba:

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

• J_G izmerite, kako dobro generator preslepi diskriminator.
• dnevnikD(G(z_i) )predstavlja log verjetnosti, da je diskriminator pravilen za ustvarjene vzorce.
• Generator želi zmanjšati to izgubo in spodbuja proizvodnjo vzorcev, ki jih diskriminator razvrsti kot prave(log D(G(z_i)), blizu 1.

Model diskriminatorja

Umetna nevronska mreža, imenovana diskriminatorski model, se uporablja v generativnih kontradiktornih omrežjih (GAN) za razlikovanje med ustvarjenim in dejanskim vnosom. Z vrednotenjem vhodnih vzorcev in dodeljevanjem verjetnosti avtentičnosti diskriminator deluje kot binarni klasifikator.

Sčasoma se diskriminator nauči razlikovati med pristnimi podatki iz nabora podatkov in umetnimi vzorci, ki jih ustvari generator. To mu omogoča postopno izpopolnjevanje parametrov in zvišanje stopnje strokovnosti.

Konvolucijski sloji ali ustrezne strukture za druge modalitete se običajno uporabljajo v njegovi arhitekturi, ko se ukvarjajo s slikovnimi podatki. Cilj kontradiktornega postopka usposabljanja je povečanje zmožnosti diskriminatorja, da natančno identificira ustvarjene vzorce kot lažne in prave vzorce kot pristne. Diskriminator postaja vse bolj diskriminatoren zaradi interakcije generatorja in diskriminatorja, kar GAN pomaga ustvariti izjemno realistične sintetične podatke na splošno.

Izguba diskriminatorja

Diskriminator zmanjša verjetnost negativnega logaritma za pravilno razvrstitev proizvedenih in dejanskih vzorcev. Ta izguba spodbudi diskriminatorja, da natančno kategorizira ustvarjene vzorce kot ponarejene in prave vzorce z naslednjo enačbo:
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_Doceni diskriminatorjevo sposobnost razločevanja med proizvedenimi in dejanskimi vzorci.
• Verjetnost dnevnika, da bo diskriminator natančno kategoriziral dejanske podatke, predstavljalogD(x_i).
• Možnost dnevnika, da bi diskriminator pravilno kategoriziral ustvarjene vzorce kot lažne, je predstavljena zlog⁡(1-D(G(z_i))).
• Diskriminator želi zmanjšati to izgubo z natančno identifikacijo umetnih in resničnih vzorcev.

Najmanjša izguba

V generativnem kontradiktornem omrežju (GAN) formulo minimalne izgube zagotavlja:

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

• G je generatorsko omrežje, D pa diskriminatorsko omrežje
• Dejanski vzorci podatkov, pridobljeni iz dejanske distribucije podatkovp_{data}(x) so predstavljeni z x.
• Naključni šum, vzorčen iz prejšnje porazdelitvep_z(z) (običajno normalna ali enakomerna porazdelitev) je predstavljen z z.
• D(x) predstavlja diskriminatorjevo verjetnost, da pravilno identificira dejanske podatke kot resnične.
• D(G(z)) je verjetnost, da bo diskriminator identificiral ustvarjene podatke, ki prihajajo iz generatorja, kot verodostojne.

Kako deluje GAN?

Koraki, vključeni v delovanje GAN:

1. Inicializacija: Ustvarjeni sta dve nevronski mreži: generator (G) in diskriminator (D).
   • G je zadolžen za ustvarjanje novih podatkov, kot so slike ali besedilo, ki so zelo podobni resničnim podatkom.
   • D deluje kot kritik in poskuša razlikovati med resničnimi podatki (iz nabora podatkov za usposabljanje) in podatki, ki jih ustvari G.
2. Prva poteza generatorja: G kot vhod vzame naključni vektor šuma. Ta vektor šuma vsebuje naključne vrednosti in deluje kot izhodišče za G-jev proces ustvarjanja. Z uporabo svojih notranjih plasti in naučenih vzorcev G pretvori vektor šuma v nov vzorec podatkov, kot je ustvarjena slika.
3. Diskriminatorjeva poteza: D prejme dve vrsti vnosov:
   • Realni vzorci podatkov iz nabora podatkov o usposabljanju.
   • Vzorci podatkov, ki jih je ustvaril G v prejšnjem koraku. D-jeva naloga je analizirati vsak vnos in ugotoviti, ali gre za resnične podatke ali nekaj, kar je G zakuhal. Izpiše rezultat verjetnosti med 0 in 1. Rezultat 1 pomeni, da so podatki verjetno resnični, 0 pa pomeni, da so lažni.
4. Učni proces: Zdaj nastopi kontradiktorni del:
   • Če D pravilno identificira resnične podatke kot resnične (ocena blizu 1) in ustvarjene podatke kot ponarejene (ocena blizu 0), sta tako G kot D v majhni meri nagrajena. To je zato, ker oba dobro opravljata svoje delo.
   • Vendar je ključno nenehno izboljševanje. Če D dosledno prepozna vse pravilno, se ne bo veliko naučil. Torej, cilj je, da G na koncu pretenta D.
5. Izboljšava generatorja:
   • Ko D napačno označi G-jevo stvaritev kot resnično (ocena blizu 1), je to znak, da je G na pravi poti. V tem primeru G prejme pomembno pozitivno posodobitev, medtem ko D prejme kazen, ker je bil preslepljen.
   • Te povratne informacije pomagajo G izboljšati svoj proces generiranja, da ustvari bolj realistične podatke.
6. Prilagoditev diskriminatorja:
   • Nasprotno, če D pravilno identificira G-jeve ponarejene podatke (rezultat blizu 0), vendar G ne prejme nagrade, je D še bolj okrepljen v svojih sposobnostih razlikovanja.
   • Ta nenehni dvoboj med G in D sčasoma izboljša obe mreži.

Ko usposabljanje napreduje, G postaja boljši pri ustvarjanju realističnih podatkov, zato D težje opazi razliko. V idealnem primeru G postane tako spreten, da D ne more zanesljivo razlikovati resničnih od lažnih podatkov. Na tej točki velja, da je G dobro usposobljen in se lahko uporablja za ustvarjanje novih, realističnih vzorcev podatkov.

kakšne so dimenzije zaslona mojega računalnika

Implementacija Generative Adversarial Network (GAN)

Sledili in razumeli bomo korake, da bi razumeli, kako se izvaja GAN:

1. korak: uvoz zahtevanih knjižnic

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