IMIDLERTID (Generative Adversarial Network) repræsenterer en banebrydende tilgang til generativ modellering inden for deep learning, der ofte udnytter arkitekturer som f.eks. konvolutionelle neurale netværk . Målet med generativ modellering er autonomt at identificere mønstre i inputdata, hvilket gør det muligt for modellen at producere nye eksempler, der kan tænkes at ligne det originale datasæt.

Denne artikel dækker alt, hvad du behøver at vide om GAN, GAN's arkitektur, GAN's funktion og typer af GAN-modeller og så videre.

Indholdsfortegnelse

• Hvad er et generativt modstandsnetværk?
• Typer af GAN'er
• Arkitektur af GAN'er
• Hvordan fungerer en GAN?
• Implementering af et GAN
• Anvendelse af Generative Adversarial Networks (GAN'er)
• Fordele ved GAN
• Ulemper ved GAN
• GAN (Generative Adversarial Network) - ofte stillede spørgsmål

Hvad er et generativt modstandsnetværk?

Generative Adversarial Networks (GAN'er) er en kraftfuld klasse af neurale netværk, der bruges til en uovervåget læring . GAN'er består af to neurale netværk , en diskriminator og en generator. De bruger modstridende træning til at producere kunstige data, der er identiske med faktiske data.

• Generatoren forsøger at narre Diskriminatoren, som har til opgave at skelne nøjagtigt mellem producerede og ægte data, ved at producere tilfældige støjprøver.
• Realistiske prøver af høj kvalitet produceres som et resultat af denne konkurrenceprægede interaktion, som driver begge netværk mod avancement.
• GAN'er har vist sig at være yderst alsidige kunstig intelligens-værktøjer, hvilket fremgår af deres omfattende brug i billedsyntese, stiloverførsel og tekst-til-billede syntese.
• De har også revolutioneret generativ modellering.

Gennem modstridende træning engagerer disse modeller sig i et konkurrencepræget samspil, indtil generatoren bliver dygtig til at skabe realistiske prøver, og narre diskriminatoren cirka halvdelen af ​​tiden.

Generative Adversarial Networks (GAN'er) kan opdeles i tre dele:

• Generativ: At lære en generativ model, som beskriver hvordan data genereres i form af en sandsynlighedsmodel.
• Modstridende: Ordet modstander refererer til at sætte en ting op mod en anden. Det betyder, at i forbindelse med GAN'er sammenlignes det generative resultat med de faktiske billeder i datasættet. En mekanisme kendt som en diskriminator bruges til at anvende en model, der forsøger at skelne mellem ægte og falske billeder.
• Netværk: Brug dybe neurale netværk som kunstig intelligens (AI) algoritmer til træningsformål.

Typer af GAN'er

1. Vanilje GAN: Dette er den enkleste type GAN. Her er Generatoren og Diskriminatoren simple en grundlæggende flerlagsperceptroner . I vanilla GAN er algoritmen virkelig enkel, den forsøger at optimere den matematiske ligning vha. stokastisk gradientnedstigning.
2. Betinget GAN (CGAN): CGAN kan beskrives som en dyb læring metode, hvori nogle betingede parametre er sat på plads .
   • I CGAN tilføjes en ekstra parameter 'y' til Generatoren for at generere de tilsvarende data.
   • Der sættes også etiketter på input til Diskriminatoren for at Diskriminatoren kan hjælpe med at skelne de rigtige data fra de falske genererede data.
3. Deep Convolutional GAN ​​(DCGAN): DCGAN er en af ​​de mest populære og også de mest succesrige implementeringer af GAN. Den er sammensat af ConvNets i stedet for flerlagsperceptroner .
   • ConvNets er implementeret uden max pooling, som faktisk er erstattet af foldningsskridt.
   • Desuden er lagene ikke fuldt forbundet.
4. Laplacian Pyramid GAN (LAPGAN): Det Laplacian pyramide er en lineær inverterbar billedrepræsentation bestående af et sæt båndpasbilleder med en oktavafstand fra hinanden plus en lavfrekvent residual.
   • Denne tilgang bruger flere antal Generator- og Diskriminator-netværk og forskellige niveauer af Laplacian-pyramiden.
   • Denne tilgang bruges hovedsageligt, fordi den producerer billeder af meget høj kvalitet. Billedet nedsamples først ved hvert lag af pyramiden og derefter opskaleres det igen ved hvert lag i en baglæns passage, hvor billedet får noget støj fra det betingede GAN ved disse lag, indtil det når sin oprindelige størrelse.
5. Super opløsning GAN (SRGAN): SRGAN som navnet antyder er en måde at designe et GAN på, hvor en dybe neurale netværk bruges sammen med et kontradiktorisk netværk for at producere billeder i højere opløsning. Denne type GAN er især nyttig til optimal opskalering af native lavopløsningsbilleder for at forbedre deres detaljer og minimere fejl, mens du gør det.

Arkitektur af GAN'er

Et Generative Adversarial Network (GAN) er sammensat af to primære dele, som er Generatoren og Diskriminatoren.

Generator model

Et nøgleelement, der er ansvarligt for at skabe friske, nøjagtige data i et Generative Adversarial Network (GAN) er generatormodellen. Generatoren tager tilfældig støj som input og konverterer den til komplekse dataeksempler, såsom tekst eller billeder. Det er almindeligvis afbildet som et dybt neuralt netværk.

Træningsdataens underliggende fordeling fanges af lag af indlærelige parametre i dets design gennem træning. Generatoren justerer sit output for at producere samples, der nøje efterligner virkelige data, mens den trænes ved at bruge backpropagation til at finjustere sine parametre.

Generatorens evne til at generere varierede prøver af høj kvalitet, der kan narre diskriminatoren, er det, der gør det vellykket.

Generatortab

Formålet med generatoren i en GAN er at producere syntetiske prøver, der er realistiske nok til at narre diskriminatoren. Generatoren opnår dette ved at minimere dens tabsfunktionJ_G. Tabet minimeres, når log-sandsynligheden er maksimeret, dvs. når diskriminatoren med stor sandsynlighed klassificerer de genererede prøver som reelle. Følgende ligning er givet nedenfor:

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

• J_G måle, hvor godt generatoren narrer diskriminatoren.
• logD(G(z_i) )repræsenterer log-sandsynlighed for, at diskriminatoren er korrekt for genererede prøver.
• Generatoren sigter mod at minimere dette tab og tilskynde til produktion af prøver, som diskriminatoren klassificerer som reelle(log D(G(z_i)), tæt på 1.

Diskriminator model

Et kunstigt neuralt netværk kaldet en diskriminatormodel bruges i Generative Adversarial Networks (GAN'er) til at skelne mellem genereret og faktisk input. Ved at evaluere inputprøver og allokere sandsynlighed for autenticitet fungerer diskriminatoren som en binær klassifikator.

Over tid lærer diskriminatoren at skelne mellem ægte data fra datasættet og kunstige prøver skabt af generatoren. Dette giver den mulighed for gradvist at finpudse sine parametre og øge sit færdighedsniveau.

Konvolutionerende lag eller relevante strukturer for andre modaliteter bruges sædvanligvis i dens arkitektur, når der er tale om billeddata. Maksimering af diskriminatorens kapacitet til nøjagtigt at identificere genererede prøver som svigagtige og rigtige prøver som autentiske er målet med den kontradiktoriske træningsprocedure. Diskriminatoren bliver mere og mere diskriminerende som et resultat af generatorens og diskriminatorens interaktion, hvilket hjælper GAN med at producere ekstremt realistisk udseende syntetiske data generelt.

Tab af diskriminator

Diskriminatoren reducerer den negative logsandsynlighed for korrekt klassificering af både producerede og reelle prøver. Dette tab tilskynder diskriminatoren til nøjagtigt at kategorisere genererede prøver som falske og rigtige 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 at skelne mellem producerede og faktiske prøver.
• Logsandsynligheden for, at diskriminatoren nøjagtigt vil kategorisere reelle data, er repræsenteret aflogD(x_i).
• Log chancen for, at diskriminatoren korrekt ville kategorisere genererede prøver som falske, er repræsenteret aflog⁡(1-D(G(z_i))).
• Diskriminatoren sigter mod at reducere dette tab ved nøjagtigt at identificere kunstige og rigtige prøver.

MinMax tab

I et Generative Adversarial Network (GAN) er minimumstabsformlen leveret af:

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 generatornetværk og er D er diskriminatornetværket
• Faktiske dataprøver opnået fra den sande datafordelingp_{data}(x) er repræsenteret ved x.
• Tilfældig støj samplet fra en tidligere distributionp_z(z) (normalt en normal eller ensartet fordeling) er repræsenteret ved z.
• D(x) repræsenterer diskriminatorens sandsynlighed for korrekt at identificere faktiske data som reelle.
• D(G(z)) er sandsynligheden for, at diskriminatoren vil identificere genererede data, der kommer fra generatoren, som autentiske.

Hvordan fungerer en GAN?

De trin, der er involveret i, hvordan en GAN fungerer:

1. Initialisering: Der skabes to neurale netværk: en Generator (G) og en Diskriminator (D).
   • G har til opgave at skabe nye data, som billeder eller tekst, der ligner virkelige data.
   • D fungerer som en kritiker, der forsøger at skelne mellem reelle data (fra et træningsdatasæt) og data genereret af G.
2. Generatorens første træk: G tager en tilfældig støjvektor som input. Denne støjvektor indeholder tilfældige værdier og fungerer som udgangspunkt for G’s skabelsesproces. Ved at bruge dets interne lag og indlærte mønstre transformerer G støjvektoren til en ny dataprøve, som et genereret billede.
3. Diskriminatorens tur: D modtager to slags input:
   • Reelle dataprøver fra træningsdatasættet.
   • Dataeksemplerne genereret af G i det foregående trin. D's opgave er at analysere hvert input og afgøre, om det er rigtige data eller noget G kogt sammen. Den udsender en sandsynlighedsscore mellem 0 og 1. En score på 1 angiver, at dataene sandsynligvis er reelle, og 0 antyder, at de er falske.
4. Læringsprocessen: Nu kommer den modstridende del ind:
   • Hvis D korrekt identificerer reelle data som reelle (score tæt på 1) og genererede data som falske (score tæt på 0), bliver både G og D belønnet i en lille grad. Dette skyldes, at de begge udfører deres arbejde godt.
   • Nøglen er dog løbende at forbedre. Hvis D konsekvent identificerer alt korrekt, vil den ikke lære meget. Så målet er, at G til sidst narre D.
5. Generatorens forbedring:
   • Når D fejlagtigt mærker G’s skabelse som ægte (score tæt på 1), er det et tegn på, at G er på rette vej. I dette tilfælde får G en væsentlig positiv opdatering, mens D får en straf for at blive snydt.
   • Denne feedback hjælper G med at forbedre sin genereringsproces for at skabe mere realistiske data.
6. Diskriminatorens tilpasning:
   • Omvendt, hvis D identificerer G's falske data korrekt (score tæt på 0), men G ikke modtager nogen belønning, bliver D yderligere styrket i sine diskriminationsevner.
   • Denne igangværende duel mellem G og D forfiner begge netværk over tid.

Efterhånden som træningen skrider frem, bliver G bedre til at generere realistiske data, hvilket gør det sværere for D at se forskel. Ideelt set bliver G så dygtig, at D ikke pålideligt kan skelne ægte fra falske data. På dette tidspunkt anses G for at være veltrænet og kan bruges til at generere nye, realistiske dataprøver.

arraylist.sort

Implementering af Generative Adversarial Network (GAN)

Vi vil følge og forstå trinene for at forstå, hvordan GAN implementeres:

Trin 1: Import af de nødvendige biblioteker

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