DOCK (Generative Adversarial Network) representerar ett banbrytande tillvägagångssätt för generativ modellering inom djupinlärning, ofta med hjälp av arkitekturer som konvolutionella neurala nätverk . Målet med generativ modellering är att autonomt identifiera mönster i indata, vilket gör det möjligt för modellen att producera nya exempel som möjligen liknar den ursprungliga datamängden.

Den här artikeln täcker allt du behöver veta om GAN, arkitekturen för GAN, hur GAN fungerar och typer av GAN-modeller och så vidare.

Innehållsförteckning

• Vad är ett generativt motståndsnätverk?
• Typer av GAN
• Arkitektur av GAN
• Hur fungerar en GAN?
• Implementering av ett GAN
• Tillämpning av Generative Adversarial Networks (GAN)
• Fördelar med GAN
• Nackdelar med GAN
• GAN (Generative Adversarial Network) - Vanliga frågor

Vad är ett generativt motståndsnätverk?

Generative Adversarial Networks (GAN) är en kraftfull klass av neurala nätverk som används för en oövervakat lärande . GAN består av två neurala nätverk , en diskriminator och en generator. De använder kontradiktorisk träning för att producera artificiell data som är identisk med faktiska data.

• Generatorn försöker lura Diskriminatorn, som har till uppgift att exakt skilja mellan producerad och äkta data, genom att producera slumpmässiga brusprover.
• Realistiska prover av hög kvalitet produceras som ett resultat av denna konkurrensutsatta interaktion, som driver båda nätverken mot avancemang.
• GAN har visat sig vara mycket mångsidiga verktyg för artificiell intelligens, vilket framgår av deras omfattande användning i bildsyntes, stilöverföring och text-till-bild-syntes.
• De har också revolutionerat generativ modellering.

Genom kontradiktorisk träning deltar dessa modeller i ett konkurrenskraftigt samspel tills generatorn blir skicklig på att skapa realistiska prover, och lurar diskriminatorn ungefär halva tiden.

Generative Adversarial Networks (GAN) kan delas upp i tre delar:

• Generativ: Att lära sig en generativ modell, som beskriver hur data genereras i termer av en probabilistisk modell.
• Motståndare: Ordet motståndare syftar på att ställa en sak mot en annan. Detta innebär att i samband med GAN:er jämförs det generativa resultatet med de faktiska bilderna i datamängden. En mekanism känd som en diskriminator används för att tillämpa en modell som försöker skilja mellan verkliga och falska bilder.
• Nätverk: Använd djupa neurala nätverk som artificiell intelligens (AI) algoritmer för träningsändamål.

Typer av GAN

1. Vanilj GAN: Detta är den enklaste typen av GAN. Här är Generatorn och Diskriminatorn enkla grundläggande flerskiktsperceptroner . I vanilla GAN är algoritmen väldigt enkel, den försöker optimera den matematiska ekvationen med stokastisk gradientnedstigning.
2. Villkorligt GAN (CGAN): CGAN kan beskrivas som en Djup lärning metod där vissa villkorade parametrar har införts .
   • I CGAN läggs en extra parameter 'y' till i Generatorn för att generera motsvarande data.
   • Etiketter sätts också in i inmatningen till Diskriminatorn för att Diskriminatorn ska hjälpa till att skilja den verkliga informationen från den falska genererade informationen.
3. Deep Convolutional GAN ​​(DCGAN): DCGAN är en av de mest populära och även de mest framgångsrika implementeringarna av GAN. Den är sammansatt av ConvNets istället för flerskiktsperceptroner .
   • ConvNets implementeras utan max pooling, som i själva verket ersätts av faltningssteg.
   • Dessutom är skikten inte helt anslutna.
4. Laplacian Pyramid GAN (LAPGAN): De Laplacian pyramid är en linjär inverterbar bildrepresentation som består av en uppsättning bandpassbilder, åtskilda en oktav från varandra, plus en lågfrekvent residual.
   • Detta tillvägagångssätt använder flera antal Generator- och Discriminator-nätverk och olika nivåer av Laplacian-pyramiden.
   • Detta tillvägagångssätt används främst för att det ger bilder av mycket hög kvalitet. Bilden nedsamplas först vid varje lager av pyramiden och sedan skalas den upp igen vid varje lager i en bakåtpassning där bilden får lite brus från det villkorliga GAN vid dessa lager tills den når sin ursprungliga storlek.
5. Super Resolution GAN (SRGAN): SRGAN som namnet antyder är ett sätt att designa ett GAN där en djupa neurala nätverk används tillsammans med ett kontradiktoriskt nätverk för att producera bilder med högre upplösning. Den här typen av GAN är särskilt användbar för att optimalt uppskala inbyggda lågupplösta bilder för att förbättra deras detaljer och minimera fel medan du gör det.

Arkitektur av GAN

Ett Generative Adversarial Network (GAN) består av två primära delar, som är Generatorn och Diskriminatorn.

Generatormodell

En nyckelfaktor som är ansvarig för att skapa färsk, korrekt data i ett Generative Adversarial Network (GAN) är generatormodellen. Generatorn tar slumpmässigt brus som indata och omvandlar det till komplexa dataprover, såsom text eller bilder. Det avbildas vanligtvis som ett djupt neuralt nätverk.

Träningsdatans underliggande distribution fångas av lager av inlärbara parametrar i dess design genom träning. Generatorn justerar sin uteffekt för att producera sampel som nära efterliknar verkliga data när den tränas genom att använda backpropagation för att finjustera sina parametrar.

Generatorns förmåga att generera högkvalitativa, varierade prover som kan lura diskriminatorn är det som gör det framgångsrikt.

Generatorförlust

Syftet med generatorn i ett GAN är att producera syntetiska prover som är tillräckligt realistiska för att lura diskriminatorn. Generatorn uppnår detta genom att minimera sin förlustfunktionJ_G. Förlusten minimeras när logsannolikheten är maximerad, d.v.s. när diskriminatorn är mycket sannolikt att klassificera de genererade samplen som verkliga. Följande ekvation ges nedan:

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

• J_G mäta hur väl generatorn lurar diskriminatorn.
• loggaD(G(z_i) )representerar log-sannolikheten för att diskriminatorn är korrekt för genererade sampel.
• Generatorn syftar till att minimera denna förlust och uppmuntra produktionen av prover som diskriminatorn klassificerar som verkliga(log D(G(z_i)), nära 1.

Diskrimineringsmodell

Ett artificiellt neuralt nätverk som kallas en diskriminatormodell används i Generative Adversarial Networks (GAN) för att skilja mellan genererad och faktisk input. Genom att utvärdera ingångssampler och allokera sannolikhet för autenticitet fungerar diskriminatorn som en binär klassificerare.

Med tiden lär sig diskriminatorn att skilja mellan äkta data från datasetet och artificiella prover som skapats av generatorn. Detta gör det möjligt för den att gradvis finslipa sina parametrar och öka sin kompetensnivå.

Konvolutionerande lager eller relevanta strukturer för andra modaliteter används vanligtvis i dess arkitektur när man hanterar bilddata. Att maximera diskriminatorns förmåga att exakt identifiera genererade prover som bedrägliga och verkliga prover som autentiska är syftet med den kontradiktoriska utbildningsproceduren. Diskriminatorn blir allt mer diskriminerande som ett resultat av generatorns och diskriminatorns interaktion, vilket hjälper GAN att producera extremt realistiskt utseende syntetisk data totalt sett.

Diskrimineringsförlust

Diskriminatorn minskar sannolikheten för negativ log för att korrekt klassificera både producerade och verkliga prover. Denna förlust motiverar diskriminatorn att korrekt kategorisera genererade prover som falska och riktiga prover med följande ekvation:
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_Dbedömer diskriminatorns förmåga att skilja mellan producerade och faktiska prover.
• Loggsannolikheten att diskriminatorn exakt kommer att kategorisera verklig data representeras avlogD(x_i).
• Loggchansen att diskriminatorn korrekt skulle kategorisera genererade prover som falska representeras avlog⁡(1-D(G(z_i))).
• Diskriminatorn syftar till att minska denna förlust genom att noggrant identifiera artificiella och verkliga prover.

MinMax förlust

I ett Generative Adversarial Network (GAN) tillhandahålls formeln för minimaxförlust 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)))]
Var,

• G är generatornätverket och är D är diskriminatornätverket
• Faktiska dataprov erhållna från den sanna datadistributionenp_{data}(x) representeras av x.
• Slumpmässigt brus samplat från en tidigare distributionp_z(z) (vanligtvis en normal eller enhetlig fördelning) representeras av z.
• D(x) representerar diskriminatorns sannolikhet att korrekt identifiera faktiska data som verkliga.
• D(G(z)) är sannolikheten att diskriminatorn kommer att identifiera genererad data som kommer från generatorn som autentisk.

Hur fungerar en GAN?

Stegen som är involverade i hur en GAN fungerar:

1. Initiering: Två neurala nätverk skapas: en Generator (G) och en Diskriminator (D).
   • G har till uppgift att skapa ny data, som bilder eller text, som liknar verklig data.
   • D fungerar som en kritiker och försöker skilja mellan verkliga data (från en träningsdatauppsättning) och data som genereras av G.
2. Generatorns första drag: G tar en slumpmässig brusvektor som indata. Denna brusvektor innehåller slumpmässiga värden och fungerar som startpunkten för G:s skapelseprocess. Med hjälp av dess interna lager och inlärda mönster omvandlar G brusvektorn till ett nytt dataprov, som en genererad bild.
3. Diskriminatorns tur: D tar emot två typer av ingångar:
   • Verkliga dataprover från träningsdatauppsättningen.
   • Datasamplen genererade av G i föregående steg. D:s jobb är att analysera varje ingång och avgöra om det är riktiga data eller något som G kokat ihop. Det ger en sannolikhetspoäng mellan 0 och 1. En poäng på 1 indikerar att data sannolikt är verkliga, och 0 tyder på att det är falskt.
4. Inlärningsprocessen: Nu kommer den motstridiga delen in:
   • Om D korrekt identifierar verklig data som verklig (poäng nära 1) och genererad data som falsk (poäng nära 0), belönas både G och D i liten grad. Detta beror på att de båda gör sitt jobb bra.
   • Nyckeln är dock att ständigt förbättra. Om D konsekvent identifierar allt korrekt kommer den inte att lära sig mycket. Så målet är att G så småningom ska lura D.
5. Generatorns förbättring:
   • När D av misstag märker G:s skapelse som verklig (poäng nära 1) är det ett tecken på att G är på rätt väg. I det här fallet får G en betydande positiv uppdatering, medan D får ett straff för att ha blivit lurad.
   • Denna feedback hjälper G att förbättra sin genereringsprocess för att skapa mer realistisk data.
6. Diskriminatorns anpassning:
   • Omvänt, om D identifierar G:s falska data korrekt (poäng nära 0), men G inte får någon belöning, stärks D ytterligare i sin diskrimineringsförmåga.
   • Denna pågående duell mellan G och D förfinar båda nätverken över tid.

Allt eftersom träningen fortskrider blir G bättre på att generera realistiska data, vilket gör det svårare för D att se skillnad. Helst blir G så skicklig att D inte på ett tillförlitligt sätt kan skilja verklig från falsk data. Vid denna tidpunkt anses G vara vältränad och kan användas för att generera nya, realistiska dataprover.

unix toppkommando

Implementering av Generative Adversarial Network (GAN)

Vi kommer att följa och förstå stegen för att förstå hur GAN implementeras:

Steg 1: Importera de nödvändiga biblioteken

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