MALGRAT AIXÒ (Generative Adversarial Network) representa un enfocament d'avantguarda per al modelatge generatiu dins de l'aprenentatge profund, sovint aprofitant arquitectures com ara xarxes neuronals convolucionals . L'objectiu del modelatge generatiu és identificar de manera autònoma patrons en les dades d'entrada, permetent que el model produeixi nous exemples que s'assemblin factiblement al conjunt de dades original.

Aquest article cobreix tot el que necessites saber GAN, l'arquitectura de GAN, el funcionament de GAN i els tipus de models GAN, etc.

Taula de contingut

• Què és una xarxa adversària generativa?
• Tipus de GAN
• Arquitectura de GAN
• Com funciona un GAN?
• Implementació d'un GAN
• Aplicació de xarxes generatives adversàries (GAN)
• Avantatges de GAN
• Inconvenients de GAN
• GAN (Generative Adversarial Network) - Preguntes freqüents

Què és una xarxa adversària generativa?

Les xarxes generatives adversàries (GAN) són una potent classe de xarxes neuronals que s'utilitzen per a aprenentatge no supervisat . Els GAN estan formats per dos xarxes neuronals , un discriminador i un generador. Utilitzen l'entrenament adversari per produir dades artificials que són idèntiques a les dades reals.

• El generador intenta enganyar el discriminador, que té l'encàrrec de distingir amb precisió entre dades produïdes i genuïnes, produint mostres de soroll aleatòries.
• Com a resultat d'aquesta interacció competitiva es produeixen mostres realistes i d'alta qualitat, que impulsa ambdues xarxes cap a l'avenç.
• Els GAN estan demostrant ser eines d'intel·ligència artificial molt versàtils, com ho demostra el seu ampli ús en la síntesi d'imatges, la transferència d'estils i la síntesi de text a imatge.
• També han revolucionat el modelatge generatiu.

Mitjançant l'entrenament adversari, aquests models participen en una interacció competitiva fins que el generador esdevé expert en la creació de mostres realistes, enganyant el discriminador aproximadament la meitat del temps.

Les xarxes generatives adversàries (GAN) es poden dividir en tres parts:

• Generatiu: Aprendre un model generatiu, que descriu com es generen les dades en termes d'un model probabilístic.
• Adversari: La paraula adversari es refereix a posar una cosa contra una altra. Això vol dir que, en el context dels GAN, el resultat generatiu es compara amb les imatges reals del conjunt de dades. S'utilitza un mecanisme conegut com a discriminador per aplicar un model que intenta distingir entre imatges reals i falses.
• Xarxes: Utilitzeu xarxes neuronals profundes com a algorismes d'intel·ligència artificial (IA) amb finalitats d'entrenament.

Tipus de GAN

1. GAN de vainilla: Aquest és el tipus més senzill de GAN. Aquí, el generador i el discriminador són senzills i bàsics perceptrons multicapa . A vanilla GAN, l'algoritme és realment senzill, intenta optimitzar l'equació matemàtica utilitzant descens del gradient estocàstic.
2. GAN condicional (CGAN): CGAN es pot descriure com a aprenentatge profund mètode en què s'estableixen alguns paràmetres condicionals .
   • A CGAN, s'afegeix un paràmetre addicional 'y' al generador per generar les dades corresponents.
   • També es col·loquen etiquetes a l'entrada del discriminador per tal que el discriminador ajudi a distingir les dades reals de les dades falses generades.
3. GAN convolucional profund (DCGAN): DCGAN és una de les implementacions més populars i també de més èxit de GAN. Està compost per ConvNets en lloc de perceptrons multicapa .
   • Les ConvNets s'implementen sense agrupació màxima, que de fet es substitueix per un pas convolucional.
   • A més, les capes no estan completament connectades.
4. Piràmide Laplaciana GAN (LAPGAN): El Piràmide laplaciana és una representació d'imatge invertible lineal que consisteix en un conjunt d'imatges de pas de banda, espaiades una octava, més un residu de baixa freqüència.
   • Aquest plantejament utilitza múltiples números de xarxes generadores i discriminadores i diferents nivells de la piràmide laplaciana.
   • Aquest enfocament s'utilitza principalment perquè produeix imatges de molt alta qualitat. La imatge es mostra al principi a cada capa de la piràmide i després es torna a escalar a cada capa en un pas cap enrere on la imatge adquireix una mica de soroll del GAN ​​condicional en aquestes capes fins que assoleix la seva mida original.
5. Super Resolution GAN (SRGAN): SRGAN com el seu nom indica és una manera de dissenyar una GAN en la qual a xarxa neuronal profunda s'utilitza juntament amb una xarxa adversària per tal de produir imatges de major resolució. Aquest tipus de GAN és especialment útil per augmentar de manera òptima les imatges natives de baixa resolució per millorar els seus detalls minimitzant els errors mentre ho fa.

Arquitectura de GAN

Una xarxa adversària generativa (GAN) es compon de dues parts principals, que són el generador i el discriminador.

Model del generador

Un element clau responsable de crear dades fresques i precises en una xarxa generativa adversària (GAN) és el model generador. El generador pren el soroll aleatori com a entrada i el converteix en mostres de dades complexes, com ara text o imatges. Normalment es representa com una xarxa neuronal profunda.

La distribució subjacent de les dades d'entrenament és capturada per capes de paràmetres aprendre en el seu disseny mitjançant la formació. El generador ajusta la seva sortida per produir mostres que imiten de prop les dades reals a mesura que s'entrenen mitjançant la retropropagació per ajustar els seus paràmetres.

La capacitat del generador de generar mostres variades i d'alta qualitat que poden enganyar el discriminador és el que fa que tingui èxit.

Pèrdua del generador

L'objectiu del generador en un GAN és produir mostres sintètiques prou realistes com per enganyar el discriminador. El generador aconsegueix això minimitzant la seva funció de pèrduaJ_G. La pèrdua es minimitza quan es maximitza la probabilitat logarítmica, és a dir, quan el discriminador és molt probable que classifiqui les mostres generades com a reals. A continuació es presenta l'equació següent:

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

• J_G mesura fins a quin punt el generador està enganyant el discriminador.
• registreD(G(z_i) )representa la probabilitat logarítmica que el discriminador sigui correcte per a les mostres generades.
• El generador pretén minimitzar aquesta pèrdua, fomentant la producció de mostres que el discriminador classifica com a reals.(log D(G(z_i)), prop de 1.

Model discriminador

Una xarxa neuronal artificial anomenada model discriminador s'utilitza a les xarxes generatives adversàries (GAN) per diferenciar entre l'entrada generada i la real. Mitjançant l'avaluació de mostres d'entrada i l'assignació de la probabilitat d'autenticitat, el discriminador funciona com a classificador binari.

Amb el temps, el discriminador aprèn a diferenciar entre dades genuïnes del conjunt de dades i mostres artificials creades pel generador. Això li permet perfeccionar progressivament els seus paràmetres i augmentar el seu nivell de competència.

Capes convolucionals o estructures pertinents per a altres modalitats s'utilitzen normalment en la seva arquitectura quan es tracta de dades d'imatge. Maximitzar la capacitat del discriminador per identificar amb precisió les mostres generades com a fraudulentes i les mostres reals com a autèntiques és l'objectiu del procediment d'entrenament contradictori. El discriminador és cada cop més discriminant com a resultat de la interacció del generador i el discriminador, cosa que ajuda al GAN ​​a produir dades sintètiques d'aspecte extremadament realista en general.

Pèrdua del discriminador

El discriminador redueix la probabilitat de registre negatiu de classificar correctament tant les mostres produïdes com les reals. Aquesta pèrdua incentiva el discriminador a categoritzar amb precisió les mostres generades com a mostres falses i reals amb l'equació següent:
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_Davalua la capacitat del discriminador per discernir entre mostres produïdes i mostres reals.
• La probabilitat de registre que el discriminador categoritzarà amb precisió les dades reals es representalogD(x_i).
• La probabilitat de registre que el discriminador classifiqui correctament les mostres generades com a falses es representalog⁡(1-D(G(z_i))).
• El discriminador pretén reduir aquesta pèrdua identificant amb precisió mostres artificials i reals.

MinMax Pèrdua

En una xarxa adversària generativa (GAN), la fórmula de pèrdua minimax es proporciona:

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

• G és la xarxa generadora i és D és la xarxa discriminadora
• Mostres de dades reals obtingudes de la distribució de dades realsp_{data}(x) es representen per x.
• Soroll aleatori mostrat d'una distribució anteriorp_z(z) (normalment una distribució normal o uniforme) es representa per z.
• D(x) representa la probabilitat del discriminador d'identificar correctament les dades reals com a reals.
• D(G(z)) és la probabilitat que el discriminador identifiqui les dades generades procedents del generador com a autèntiques.

Com funciona un GAN?

Els passos implicats en el funcionament d'un GAN:

1. Inicialització: Es creen dues xarxes neuronals: un generador (G) i un discriminador (D).
   • G té l'encàrrec de crear dades noves, com ara imatges o text, que s'assemblen molt a les dades reals.
   • D actua com a crític, intentant distingir entre dades reals (d'un conjunt de dades d'entrenament) i les dades generades per G.
2. Primer moviment del generador: G pren un vector de soroll aleatori com a entrada. Aquest vector de soroll conté valors aleatoris i actua com a punt de partida per al procés de creació de G. Utilitzant les seves capes internes i patrons apresos, G transforma el vector de soroll en una nova mostra de dades, com una imatge generada.
3. El torn del discriminador: D rep dos tipus d'entrades:
   • Mostres de dades reals del conjunt de dades d'entrenament.
   • Les mostres de dades generades per G al pas anterior. La feina de D és analitzar cada entrada i determinar si es tracta de dades reals o d'alguna cosa que G ha preparat. Emet una puntuació de probabilitat entre 0 i 1. Una puntuació d'1 indica que les dades probablement són reals i 0 suggereix que són falses.
4. El procés d'aprenentatge: Ara, la part contradictòria entra:
   • Si D identifica correctament les dades reals com a reals (puntuació propera a 1) i les dades generades com a falses (puntuació propera a 0), tant G com D es premien en petit grau. Això és perquè tots dos estan fent bé la seva feina.
   • No obstant això, la clau és millorar contínuament. Si D ho identifica tot correctament, no aprendrà gaire. Per tant, l'objectiu és que G finalment enganyi D.
5. Millora del generador:
   • Quan D etiqueta per error la creació de G com a real (puntuació propera a 1), és un senyal que G va pel bon camí. En aquest cas, G rep una actualització positiva significativa, mentre que D rep una penalització per ser enganyat.
   • Aquest feedback ajuda a G a millorar el seu procés de generació per crear dades més realistes.
6. Adaptació del discriminador:
   • Per contra, si D identifica correctament les dades falses de G (puntuació propera a 0), però G no rep cap recompensa, D es reforça encara més en les seves capacitats de discriminació.
   • Aquest duel en curs entre G i D perfecciona ambdues xarxes al llarg del temps.

A mesura que avança l'entrenament, G millora a l'hora de generar dades realistes, cosa que fa que sigui més difícil que D noti la diferència. L'ideal és que G sigui tan hàbil que D no pugui distingir de manera fiable les dades reals de les falses. En aquest punt, G es considera ben entrenat i es pot utilitzar per generar mostres de dades noves i realistes.

què és svn checkout

Implementació de la Xarxa Adversarial Generativa (GAN)

Seguirem i entendrem els passos per entendre com s'implementa GAN:

Pas 1: importació de les biblioteques necessàries

Python 3

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