DERIMOT (Generative Adversarial Network) representerer en banebrytende tilnærming til generativ modellering innen dyp læring, ofte ved å utnytte arkitekturer som konvolusjonelle nevrale nettverk . Målet med generativ modellering er å autonomt identifisere mønstre i inputdata, slik at modellen kan produsere nye eksempler som muligens ligner det originale datasettet.

Denne artikkelen dekker alt du trenger å vite om GAN, arkitekturen til GAN, GANs virkemåte og typer GAN-modeller, og så videre.

Innholdsfortegnelse

• Hva er et generativt motstandsnettverk?
• Typer GAN-er
• Arkitektur av GAN-er
• Hvordan fungerer en GAN?
• Implementering av en GAN
• Anvendelse av Generative Adversarial Networks (GAN)
• Fordeler med GAN
• Ulemper med GAN
• GAN (Generative Adversarial Network) - Vanlige spørsmål

Hva er et generativt motstandsnettverk?

Generative Adversarial Networks (GANs) er en kraftig klasse av nevrale nettverk som brukes til en uovervåket læring . GAN-er består av to nevrale nettverk , en diskriminator og en generator. De bruker motstandertrening for å produsere kunstige data som er identiske med faktiske data.

• Generatoren forsøker å lure Diskriminatoren, som har i oppgave å skille nøyaktig mellom produserte og ekte data, ved å produsere tilfeldige støyprøver.
• Realistiske prøver av høy kvalitet produseres som et resultat av denne konkurransedyktige interaksjonen, som driver begge nettverkene mot avansement.
• GAN-er viser seg å være svært allsidige verktøy for kunstig intelligens, noe som fremgår av deres omfattende bruk i bildesyntese, stiloverføring og tekst-til-bilde-syntese.
• De har også revolusjonert generativ modellering.

Gjennom motstridende trening deltar disse modellene i et konkurrerende samspill inntil generatoren blir flink til å lage realistiske prøver, og lurer diskriminatoren omtrent halvparten av tiden.

Generative Adversarial Networks (GANs) kan deles inn i tre deler:

• Generativ: Å lære en generativ modell, som beskriver hvordan data genereres i form av en sannsynlighetsmodell.
• Motstander: Ordet motstander refererer til å sette en ting opp mot en annen. Dette betyr at i sammenheng med GAN-er, sammenlignes det generative resultatet med de faktiske bildene i datasettet. En mekanisme kjent som en diskriminator brukes til å bruke en modell som forsøker å skille mellom ekte og falske bilder.
• Nettverk: Bruk dype nevrale nettverk som kunstig intelligens (AI) algoritmer for treningsformål.

Typer GAN-er

1. Vanilje GAN: Dette er den enkleste typen GAN. Her er Generatoren og Diskriminatoren enkle og grunnleggende flerlags perseptroner . I vanilje GAN er algoritmen veldig enkel, den prøver å optimalisere den matematiske ligningen ved å bruke stokastisk gradientnedstigning.
2. Betinget GAN (CGAN): CGAN kan beskrives som en dyp læring metode der noen betingede parametere er satt på plass .
   • I CGAN legges en ekstra parameter 'y' til generatoren for å generere de tilsvarende dataene.
   • Etiketter settes også inn i inndataene til Diskriminatoren for at Diskriminatoren skal hjelpe til med å skille de virkelige dataene fra de falske genererte dataene.
3. Deep Convolutional GAN ​​(DCGAN): DCGAN er en av de mest populære og også de mest vellykkede implementeringene av GAN. Den er sammensatt av ConvNets i stedet for flerlags perseptroner .
   • ConvNets er implementert uten maks pooling, som faktisk er erstattet av konvolusjonsskritt.
   • Lagene er heller ikke helt koblet sammen.
4. Laplacian Pyramid GAN (LAPGAN): De Laplacian pyramide er en lineær inverterbar bilderepresentasjon som består av et sett med båndpassbilder med en oktavavstand fra hverandre, pluss en lavfrekvent rest.
   • Denne tilnærmingen bruker flere antall Generator- og Diskriminator-nettverk og forskjellige nivåer av Laplacian-pyramiden.
   • Denne tilnærmingen brukes hovedsakelig fordi den gir bilder av svært høy kvalitet. Bildet nedsamples først ved hvert lag av pyramiden og deretter oppskaleres det igjen ved hvert lag i en bakoverpassering der bildet får noe støy fra det betingede GAN ved disse lagene til det når sin opprinnelige størrelse.
5. Superoppløsning GAN (SRGAN): SRGAN som navnet antyder er en måte å designe en GAN der en dypt nevrale nettverk brukes sammen med et motstridende nettverk for å produsere bilder med høyere oppløsning. Denne typen GAN er spesielt nyttig for optimal oppskalering av native lavoppløsningsbilder for å forbedre detaljene og minimere feil mens du gjør det.

Arkitektur av GAN-er

Et Generative Adversarial Network (GAN) er sammensatt av to primære deler, som er Generatoren og Diskriminatoren.

Generator modell

Et nøkkelelement som er ansvarlig for å lage ferske, nøyaktige data i et Generative Adversarial Network (GAN) er generatormodellen. Generatoren tar tilfeldig støy som input og konverterer den til komplekse dataeksempler, for eksempel tekst eller bilder. Det er ofte avbildet som et dypt nevralt nettverk.

Treningsdataens underliggende distribusjon fanges opp av lag med parametere som kan læres i utformingen gjennom trening. Generatoren justerer utgangen for å produsere prøver som tett etterligner virkelige data mens den trenes ved å bruke tilbakepropagering for å finjustere parameterne.

Generatorens evne til å generere høykvalitets, varierte prøver som kan lure diskriminatoren er det som gjør den vellykket.

Generatortap

Målet med generatoren i en GAN er å produsere syntetiske prøver som er realistiske nok til å lure diskriminatoren. Generatoren oppnår dette ved å minimere tapsfunksjonenJ_G. Tapet minimeres når log-sannsynligheten er maksimert, dvs. når diskriminatoren er svært sannsynlig å klassifisere de genererte samplene som reelle. Følgende ligning er gitt nedenfor:

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

• J_G måle hvor godt generatoren lurer diskriminatoren.
• LoggD(G(z_i) )representerer log-sannsynligheten for at diskriminatoren er korrekt for genererte prøver.
• Generatoren har som mål å minimere dette tapet, og oppmuntre til produksjon av prøver som diskriminatoren klassifiserer som ekte(log D(G(z_i)), nær 1.

Diskrimineringsmodell

Et kunstig nevralt nettverk kalt en diskriminatormodell brukes i Generative Adversarial Networks (GAN) for å skille mellom generert og faktisk input. Ved å evaluere inngangsprøver og allokere sannsynlighet for autentisitet, fungerer diskriminatoren som en binær klassifikator.

Over tid lærer diskriminatoren å skille mellom ekte data fra datasettet og kunstige prøver laget av generatoren. Dette lar den gradvis finpusse parameterne og øke ferdighetsnivået.

Konvolusjonslag eller relevante strukturer for andre modaliteter brukes vanligvis i dens arkitektur når man arbeider med bildedata. Å maksimere diskriminatorens kapasitet til å nøyaktig identifisere genererte prøver som uredelige og ekte prøver som autentiske er målet med den kontradiktoriske opplæringsprosedyren. Diskriminatoren blir stadig mer diskriminerende som et resultat av generatorens og diskriminatorens interaksjon, noe som hjelper GAN å produsere ekstremt realistisk utseende syntetiske data totalt sett.

Tap av diskriminator

Diskriminatoren reduserer sannsynligheten for negativ logg for riktig klassifisering av både produserte og reelle prøver. Dette tapet motiverer diskriminatoren til nøyaktig å kategorisere genererte prøver som falske og ekte prøver med følgende ligning:
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_Dvurderer diskriminatorens evne til å skille mellom produserte og faktiske prøver.
• Loggsannsynligheten for at diskriminatoren nøyaktig vil kategorisere ekte data er representert avlogD(x_i).
• Loggsansen for at diskriminatoren korrekt vil kategorisere genererte prøver som falske er representert avlog⁡(1-D(G(z_i))).
• Diskriminatoren har som mål å redusere dette tapet ved nøyaktig å identifisere kunstige og ekte prøver.

MinMax Tap

I et Generative Adversarial Network (GAN) er minimumstapsformelen gitt av:

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

• G er generatornettverk og er D er diskriminatornettverket
• Faktiske dataprøver hentet fra den sanne datadistribusjonenp_{data}(x) er representert ved x.
• Tilfeldig støy samplet fra en tidligere distribusjonp_z(z) (vanligvis en normal eller ensartet fordeling) er representert ved z.
• D(x) representerer diskriminatorens sannsynlighet for å korrekt identifisere faktiske data som reelle.
• D(G(z)) er sannsynligheten for at diskriminatoren vil identifisere genererte data som kommer fra generatoren som autentiske.

Hvordan fungerer en GAN?

Trinnene involvert i hvordan en GAN fungerer:

1. Initialisering: To nevrale nettverk opprettes: en Generator (G) og en Diskriminator (D).
   • G har i oppgave å lage nye data, som bilder eller tekst, som ligner på ekte data.
   • D fungerer som en kritiker, og prøver å skille mellom reelle data (fra et treningsdatasett) og dataene generert av G.
2. Generatorens første trekk: G tar en tilfeldig støyvektor som input. Denne støyvektoren inneholder tilfeldige verdier og fungerer som utgangspunkt for Gs skapelsesprosess. Ved å bruke de interne lagene og innlærte mønstrene transformerer G støyvektoren til en ny dataprøve, som et generert bilde.
3. Diskriminatorens tur: D mottar to typer innganger:
   • Ekte dataprøver fra treningsdatasettet.
   • Dataprøvene generert av G i forrige trinn. Ds jobb er å analysere hver input og finne ut om det er ekte data eller noe G kokt sammen. Den gir en sannsynlighetsscore mellom 0 og 1. En poengsum på 1 indikerer at dataene sannsynligvis er ekte, og 0 antyder at de er falske.
4. Læringsprosessen: Nå kommer den motstridende delen inn:
   • Hvis D korrekt identifiserer reelle data som ekte (score nær 1) og genererte data som falske (score nær 0), blir både G og D belønnet i liten grad. Dette er fordi de begge gjør jobben sin godt.
   • Nøkkelen er imidlertid å kontinuerlig forbedre seg. Hvis D konsekvent identifiserer alt riktig, vil den ikke lære mye. Så målet er at G til slutt skal lure D.
5. Generatorens forbedring:
   • Når D feilaktig betegner Gs skapelse som ekte (score nær 1), er det et tegn på at G er på rett spor. I dette tilfellet får G en betydelig positiv oppdatering, mens D får en straff for å ha blitt lurt.
   • Denne tilbakemeldingen hjelper G med å forbedre generasjonsprosessen for å skape mer realistiske data.
6. Diskriminatorens tilpasning:
   • Omvendt, hvis D identifiserer Gs falske data korrekt (score nær 0), men G ikke mottar noen belønning, blir D ytterligere styrket i sine diskrimineringsevner.
   • Denne pågående duellen mellom G og D forfiner begge nettverkene over tid.

Etter hvert som treningen skrider frem, blir G bedre til å generere realistiske data, noe som gjør det vanskeligere for D å se forskjellen. Ideelt sett blir G så dyktig at D ikke pålitelig kan skille ekte fra falske data. På dette tidspunktet anses G som godt trent og kan brukes til å generere nye, realistiske dataprøver.

returnerer en array java

Implementering av Generative Adversarial Network (GAN)

Vi vil følge og forstå trinnene for å forstå hvordan GAN implementeres:

Trinn 1: Importere de nødvendige bibliotekene

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