NICMÉNĚ (Generative Adversarial Network) představuje špičkový přístup ke generativnímu modelování v rámci hlubokého učení, často využívající architektury jako konvoluční neuronové sítě . Cílem generativního modelování je autonomně identifikovat vzory ve vstupních datech, což modelu umožňuje vytvářet nové příklady, které se věrohodně podobají původnímu souboru dat.

Tento článek obsahuje vše, o čem potřebujete vědět GAN, architektura GAN, fungování GAN a typy modelů GAN a tak dále.

Obsah

• Co je generativní adversariální síť?
• Typy GAN
• Architektura GAN
• Jak funguje GAN?
• Implementace GAN
• Aplikace generativních adversariálních sítí (GAN)
• Výhody GAN
• Nevýhody GAN
• GAN (Generative Adversarial Network) – často kladené dotazy

Co je to generativní adversariální síť?

Generative Adversarial Networks (GAN) jsou výkonnou třídou neuronových sítí, které se používají pro učení bez dozoru . GAN se skládají ze dvou neuronové sítě , diskriminátor a generátor. K výrobě umělých dat, která jsou identická se skutečnými daty, používají trénink protivníka.

• Generátor se pokouší oklamat Diskriminátora, který má za úkol přesně rozlišovat mezi produkovanými a skutečnými daty, tím, že produkuje vzorky náhodného šumu.
• Realistické, vysoce kvalitní vzorky jsou produkovány jako výsledek této konkurenční interakce, která žene obě sítě k pokroku.
• GAN se ukazují jako vysoce univerzální nástroje umělé inteligence, o čemž svědčí jejich rozsáhlé využití při syntéze obrázků, přenosu stylů a syntéze textu na obrázek.
• Také způsobili revoluci v generativním modelování.

Prostřednictvím tréninku protivníků se tyto modely zapojují do soutěžní souhry, dokud se generátor nestane zběhlým ve vytváření realistických vzorků, přičemž diskriminátor oklame přibližně polovinu času.

Generative Adversarial Networks (GAN) lze rozdělit do tří částí:

• Generativní: Naučit se generativní model, který popisuje, jak jsou data generována z hlediska pravděpodobnostního modelu.
• Adversarial: Slovo protivník se vztahuje k postavení jedné věci proti druhé. To znamená, že v kontextu GAN se generativní výsledek porovnává se skutečnými obrázky v souboru dat. Mechanismus známý jako diskriminátor se používá k aplikaci modelu, který se pokouší rozlišit mezi skutečnými a falešnými obrázky.
• Sítě: Použijte hluboké neuronové sítě jako algoritmy umělé inteligence (AI) pro tréninkové účely.

Typy GAN

1. Vanilkový GAN: Jedná se o nejjednodušší typ GAN. Zde jsou Generátor a Diskriminátor jednoduchý základ vícevrstvé perceptrony . Ve vanilla GAN je algoritmus opravdu jednoduchý, snaží se pomocí optimalizace matematické rovnice stochastický gradientní sestup.
2. Podmíněný GAN (CGAN): CGAN lze popsat jako a hluboké učení způsob, ve kterém jsou zavedeny některé podmíněné parametry .
   • V CGAN je do Generátoru přidán další parametr ‚y‘ pro generování odpovídajících dat.
   • Štítky jsou také vloženy do vstupu pro diskriminátor, aby diskriminátor pomohl odlišit skutečná data od falešných generovaných dat.
3. Deep Convolutional GAN ​​(DCGAN): DCGAN je jednou z nejoblíbenějších a také nejúspěšnějších implementací GAN. Skládá se z ConvNets namísto vícevrstvé perceptrony .
   • ConvNets jsou implementovány bez maximálního sdružování, což je ve skutečnosti nahrazeno konvolučním krokem.
   • Vrstvy také nejsou plně propojeny.
4. Laplaciánská pyramida GAN (LAPGAN): The Laplaciánské pyramidy je lineární invertibilní obrazová reprezentace sestávající ze sady pásmových obrazů, vzdálených od sebe oktávu, plus nízkofrekvenční reziduum.
   • Tento přístup používá více čísel sítí generátorů a diskriminátorů a různé úrovně Laplaciánské pyramidy.
   • Tento přístup se používá hlavně proto, že produkuje velmi kvalitní snímky. Obraz je nejprve v každé vrstvě pyramidy převzorkován dolů a poté je znovu škálován v každé vrstvě zpětným průchodem, kde obraz získává určitý šum z podmíněného GAN v těchto vrstvách, dokud nedosáhne své původní velikosti.
5. Super rozlišení GAN (SRGAN): SRGAN jak název napovídá, jde o způsob navrhování GAN, ve kterém a hluboké neuronové sítě se používá spolu s nepřátelskou sítí za účelem vytváření obrázků s vyšším rozlišením. Tento typ GAN je zvláště užitečný při optimálním upscalingu nativních obrázků s nízkým rozlišením, aby se zlepšily jejich detaily a přitom se minimalizovaly chyby.

Architektura GAN

Generative Adversarial Network (GAN) se skládá ze dvou primárních částí, kterými jsou generátor a diskriminátor.

Model generátoru

Klíčovým prvkem zodpovědným za vytváření čerstvých a přesných dat v síti Generative Adversarial Network (GAN) je model generátoru. Generátor bere jako vstup náhodný šum a převádí jej na komplexní datové vzorky, jako je text nebo obrázky. Bývá zobrazována jako hluboká neuronová síť.

Základní distribuce tréninkových dat je zachycena vrstvami naučitelných parametrů při jejich návrhu prostřednictvím školení. Generátor upravuje svůj výstup tak, aby produkoval vzorky, které co nejvěrněji napodobují skutečná data, když jsou trénovány pomocí zpětného šíření k jemnému doladění jeho parametrů.

Schopnost generátoru generovat vysoce kvalitní, rozmanité vzorky, které mohou oklamat diskriminátor, je to, co dělá to úspěšným.

Ztráta generátoru

Cílem generátoru v GAN je produkovat syntetické vzorky, které jsou dostatečně realistické, aby oklamaly diskriminátor. Generátor toho dosahuje minimalizací své ztrátové funkceJ_G. Ztráta je minimalizována, když je logaritmická pravděpodobnost maximalizována, tj. když je vysoce pravděpodobné, že diskriminátor klasifikuje generované vzorky jako skutečné. Níže je uvedena následující rovnice:

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

• J_G měřit, jak dobře generátor klame diskriminátor.
• logD(G(z_i) )představuje logaritmickou pravděpodobnost, že diskriminátor je správný pro generované vzorky.
• Cílem generátoru je minimalizovat tuto ztrátu a podporovat produkci vzorků, které diskriminátor klasifikuje jako skutečné(log D(G(z_i)), blízko 1.

Diskriminační model

Umělá neuronová síť nazývaná diskriminátorový model se používá v Generative Adversarial Networks (GAN) k rozlišení mezi generovaným a skutečným vstupem. Vyhodnocováním vstupních vzorků a přidělováním pravděpodobnosti pravosti funguje diskriminátor jako binární klasifikátor.

Časem se diskriminátor naučí rozlišovat mezi skutečnými daty z datové sady a umělými vzorky vytvořenými generátorem. To mu umožňuje postupně zdokonalovat své parametry a zvyšovat úroveň své odbornosti.

Konvoluční vrstvy nebo příslušné struktury pro jiné modality se obvykle používají v jeho architektuře při práci s obrazovými daty. Cílem tréninkového postupu protivníka je maximalizovat schopnost diskriminátoru přesně identifikovat generované vzorky jako podvodné a skutečné vzorky jako autentické. Diskriminátor se stává stále více diskriminačním v důsledku interakce generátoru a diskriminátoru, což pomáhá GAN vytvářet celkově extrémně realisticky vypadající syntetická data.

Ztráta diskriminátoru

Diskriminátor snižuje pravděpodobnost negativního logaritmu správné klasifikace vyrobených i skutečných vzorků. Tato ztráta motivuje diskriminátor, aby přesně kategorizoval generované vzorky jako falešné a skutečné vzorky podle následující rovnice:
J_{D} = -frac{1}{m} Sigma_{i=1}^m log; D(x_{i}) – frac{1}{m}Sigma_{i=1}^m log(1 – D(G(z_{i}))

• J_Dposuzuje schopnost diskriminátoru rozlišovat mezi vyrobenými a skutečnými vzorky.
• Log pravděpodobnost, že diskriminátor přesně kategorizuje skutečná data, je reprezentovánlogD(x_i).
• Log pravděpodobnost, že diskriminátor správně kategorizuje generované vzorky jako falešné, představujelog⁡(1-D(G(z_i))).
• Diskriminátor má za cíl snížit tuto ztrátu přesnou identifikací umělých a skutečných vzorků.

MinMax Ztráta

V síti Generative Adversarial Network (GAN) poskytuje vzorec minimální ztráty:

min_{G};max_{D}(G,D) = [mathbb{E}_{x∼p_{data}}[log;D(x)] + mathbb{E}_{z∼p_{z}(z)}[log(1 – D(g(z)))]
Kde,

• G je generátorová síť a D je diskriminační síť
• Skutečné vzorky dat získané z distribuce skutečných datp_{data}(x) jsou reprezentovány x.
• Náhodný šum vzorkovaný z předchozí distribucep_z(z) (obvykle normální nebo rovnoměrné rozdělení) je reprezentováno z.
• D(x) představuje pravděpodobnost, že diskriminátor správně identifikuje skutečná data jako skutečná.
• D(G(z)) je pravděpodobnost, že diskriminátor identifikuje generovaná data pocházející z generátoru jako autentická.

Jak funguje GAN?

Kroky, které se týkají fungování GAN:

1. Inicializace: Jsou vytvořeny dvě neuronové sítě: Generátor (G) a Diskriminátor (D).
   • G má za úkol vytvářet nová data, jako jsou obrázky nebo text, která se velmi podobají skutečným datům.
   • D působí jako kritik a snaží se rozlišovat mezi skutečnými daty (z trénovací datové sady) a daty generovanými G.
2. První pohyb generátoru: G bere jako vstup vektor náhodného šumu. Tento vektor šumu obsahuje náhodné hodnoty a funguje jako výchozí bod pro proces tvorby G. Pomocí svých vnitřních vrstev a naučených vzorů transformuje G šumový vektor na nový datový vzorek, jako je vygenerovaný obrázek.
3. Na řadě diskriminátor: D přijímá dva druhy vstupů:
   • Reálné vzorky dat z trénovací datové sady.
   • Vzorky dat generované G v předchozím kroku. Úkolem D je analyzovat každý vstup a určit, zda jde o skutečná data nebo něco, co G uvařil. Výsledkem je skóre pravděpodobnosti mezi 0 a 1. Skóre 1 znamená, že data jsou pravděpodobně skutečná, a 0 znamená, že jsou falešná.
4. Proces učení: Nyní přichází na řadu nepřátelská část:
   • Pokud D správně identifikuje skutečná data jako skutečná (skóre blízké 1) a generovaná data jako falešná (skóre blízké 0), jsou G i D v malé míře odměněny. Je to proto, že oba dělají svou práci dobře.
   • Základem je však neustále se zlepšovat. Pokud D důsledně identifikuje vše správně, moc se toho nenaučí. Takže cílem je, aby G nakonec oklamal D.
5. Vylepšení generátoru:
   • Když D omylem označí stvoření G jako skutečné (skóre blízké 1), je to znamení, že G je na správné cestě. V tomto případě G obdrží významnou pozitivní aktualizaci, zatímco D obdrží trest za oklamání.
   • Tato zpětná vazba pomáhá G zlepšit proces generování a vytvářet realističtější data.
6. Adaptace diskriminátora:
   • Naopak, pokud D správně identifikuje falešná data G (skóre blízké 0), ale G nezíská žádnou odměnu, D je dále posílena ve svých rozlišovacích schopnostech.
   • Tento probíhající souboj mezi G a D v průběhu času obě sítě zdokonaluje.

Jak trénink postupuje, G se zlepšuje v generování realistických dat, takže je pro D těžší rozeznat rozdíl. V ideálním případě se G stane tak zdatným, že D nedokáže spolehlivě rozlišit skutečná data od falešných. V tomto bodě je G považováno za dobře vyškolené a lze jej použít ke generování nových, realistických vzorků dat.

java získat aktuální čas

Implementace sítě Generative Adversarial Network (GAN)

Budeme sledovat a porozumět krokům, abychom pochopili, jak je GAN implementován:

Krok 1: Import požadovaných knihoven

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