Generative Adversarial Networks: How GANs Work

A generative adversarial network, or GAN, learns to produce realistic data by playing a game against itself. One neural network invents images from random numbers. A second network looks at a mix of real and invented images and tries to say which is which. Every time the second network catches a fake, the first one gets a signal about how to improve. That game, proposed in 2014, explains why GANs made faces that fooled people and why they proved hard to train.

The night a bar argument became a new kind of AI

In 2014, Ian Goodfellow was a doctoral student in Montreal. According to a profile in MIT Technology Review, he went to the Les 3 Brasseurs pub to celebrate a fellow student's graduation, where friends asked for help with a project: getting a computer to create photos on its own. They planned to use heavy statistical analysis of images. Goodfellow doubted it would work, and over a beer he asked a different question: what if you pitted two neural networks against each other?

He went home, and while his girlfriend slept, he coded the idea. In the article's words, "it worked the first time." The paper that followed, Generative Adversarial Networks, appeared on arXiv on June 10, 2014, with Goodfellow's co-authors including Yoshua Bengio and Aaron Courville.

The existing methods that Goodfellow's friends were using produced blurry or flawed pictures, such as faces missing an ear. A GAN did not fix that overnight. The first experiments used small datasets: MNIST (handwritten digits), the Toronto Face Database, and CIFAR-10 (tiny 32 by 32 pixel photos). But the concept spread quickly because it replaced a hard problem, writing down what "a realistic image" means in mathematics, with an easier one: building a judge that can tell.

How a GAN works: the forger and the inspector

A GAN has two parts, and the best way to remember them is an old analogy. Picture a counterfeiter printing banknotes and a bank inspector examining notes. At first the counterfeiter produces scrawled paper, and the inspector spots it instantly. Each rejection tells the counterfeiter what gave the fake away, so the next batch is better. Meanwhile the inspector sees better and better fakes and has to sharpen up too.

In GAN terms:

• The generator (G) takes a vector of random numbers, called noise or a latent vector, and runs it through a neural network to produce a sample such as an image. At the start it has learned nothing, so its outputs look like static.
• The discriminator (D) takes a sample and outputs a single number between 0 and 1, its estimate of the probability that the sample is real, meaning drawn from the training set.

The generator never sees a real image directly. It learns only through the discriminator's verdicts. That detail is the whole trick: the discriminator acts as a learned loss function, one that gets stricter as the generator improves. A human never has to specify what "realistic" means. The inspector figures it out from examples.

A second analogy helps with the training dynamic. Think of two chess students who only play each other. If one is far stronger, the weaker one loses every game without learning why, and the stronger one stops improving because it is never challenged. Progress needs the two to stay roughly matched, improving in steps. GANs behave the same way, and that is the root of most of their problems.

What the random noise does

The noise vector is where variety comes from. A trained generator is a function that maps points in a space of, say, 512 dimensions to images. Nearby points tend to map to similar images, so moving smoothly between two points produces a smooth morph from one face to another. Researchers call this space the latent space, and a good part of GAN research since 2018 has been about making it easier to steer. If you want a primer on how neural networks store and use such learned representations, see How Do Neural Networks Work? The Architecture Behind Modern AI.

The math: what the minimax game says

Formally, the 2014 paper describes a two-player minimax game. Written out, the generator tries to minimize and the discriminator tries to maximize this value:

V(D, G) = E[log D(x)] + E[log(1 − D(G(z)))]

Here x is a real sample, z is random noise, and E means "average over many examples." Read each half separately.

• The first term, log D(x), is large when the discriminator gives real data a score near 1.
• The second term, log(1 − D(G(z))), is large when the discriminator gives fakes a score near 0.

The discriminator wants both terms large. The generator can only influence the second term, and it wants it small, which happens when D(G(z)) is close to 1: the discriminator believes the fake is real.

The best possible inspector

The paper proves two results that anchor the theory. First, for any fixed generator, the best possible discriminator is:

D*(x) = p_data(x) / (p_data(x) + p_g(x))

In words: the optimal inspector's confidence that a sample is real equals the share of "real" in the combined pool of real and fake. Suppose at some point x the real data has density 0.6 and the generator's samples have density 0.2. Then D*(x) = 0.6 / 0.8 = 0.75. Where the two densities are equal, D* is exactly 0.5, meaning the inspector can do no better than a coin flip.

Second, if you plug that optimal discriminator back in, the generator's objective reaches its global minimum of −log 4 (about −1.386) only when the generator's distribution exactly matches the real data distribution. The paper shows the criterion equals −log 4 plus twice the Jensen-Shannon divergence, a measure of how different two probability distributions are, which is zero only when they match. At that point D outputs 1/2 everywhere. This is the "perfect forger" state described in the original abstract: the generator recovers the training distribution, and the discriminator can only guess.

Theory versus practice

Two caveats keep this from being a guarantee. The proof assumes both networks have unlimited capacity and that you can find the optimal discriminator at every step. Real networks are finite, and real training takes small alternating gradient steps. The theory says where a perfect game would end, not that gradient descent will get there. For a gentler introduction to the optimization method involved, see How Gradient Descent Finds Better Answers.

Why the generator's loss is flipped in practice

The paper points out a practical problem with the formula above. Early in training, the generator's samples are terrible and the discriminator rejects them with high confidence. When D(G(z)) is near 0, the term log(1 − D(G(z))) is almost flat, so it gives the generator very weak gradients, the signals that tell a network which way to adjust. The authors recommend a switch: instead of minimizing log(1 − D(G(z))), train the generator to maximize log D(G(z)). The fixed point is the same, but the gradients are much stronger when the generator is losing. This version is often called the non-saturating loss, and it became the default.

One training step, in plain terms

A GAN does not train the two networks at once in the sense of a single update. It alternates. A typical loop looks like this:

1. Draw a batch of real examples from the training set.
2. Draw a batch of random noise vectors and run them through the generator to make fakes.
3. Update the discriminator so it scores the real batch higher and the fake batch lower.
4. Draw fresh noise, generate again, and score the fakes with the updated discriminator.
5. Update the generator so the discriminator's score on its fakes goes up.
6. Repeat for hundreds of thousands of iterations.

The paper describes a hyperparameter for how many discriminator updates to make per generator update. That ratio is one of the many knobs that determine whether the game stays balanced. For why this kind of repeated, large-scale arithmetic runs on graphics hardware, see How GPUs Work: Why AI Needs Them.

Why GAN training is so fragile

Most machine learning training minimizes one loss that should go down over time. A GAN has two losses that are tied together, so one network's progress changes the other's target. Watching the loss curves tells you little. A falling generator loss might mean the generator is improving, or that the discriminator has stalled.

If the discriminator wins too easily, the generator gets saturated, nearly flat feedback. This is the vanishing gradient problem the paper tried to ease with the flipped loss.

If the generator pulls ahead, it can find a few outputs that fool the current discriminator and keep producing them. The paper names this the "Helvetica scenario": the generator collapses many different noise vectors onto the same output, and diversity disappears. The authors warn that the discriminator must be kept well synchronized with the generator for this reason.

There is no single number that says "done." For classification you can measure accuracy on held-out data. A generator has no ground truth to compare with. The 2014 paper evaluated samples by fitting a Gaussian Parzen window and computing the likelihood of test data, a method the authors themselves described as high-variance and unreliable in high dimensions, but the best they knew. In 2017, Martin Heusel and colleagues introduced the Fréchet Inception Distance (FID), which compares statistics of generated and real images in the feature space of a pretrained image classifier. FID, along with the earlier Inception Score, became the standard yardstick, although both are proxies and not direct measures of human-perceived quality.

Is it tuning, or is it the algorithm?

For years, papers claimed new GAN variants that beat the old. In a 2017 study titled "Are GANs Created Equal?", Mario Lucic and colleagues ran a large comparison. They reported that most models reach similar scores given enough hyperparameter tuning and random restarts, and that they found no evidence any tested algorithm consistently beat the non-saturating GAN from the 2014 paper. The authors concluded that apparent gains often came from more compute and tuning rather than fundamental algorithmic change. That finding is a useful correction to a field that tends to credit architecture when the real driver is effort.

Mode collapse: the GAN's characteristic failure

Imagine training a GAN on photos of dogs. The generator finds that one image, a clean photo of a golden retriever on grass, reliably gets a high score. Why risk a dachshund when the retriever works? So it produces that dog, with minor variations, again and again. That is mode collapse: the generator covers only a few modes, or peaks, of the real distribution and ignores the rest.

The cause is structural. The generator is rewarded for fooling the discriminator at this moment, and nothing in its loss rewards variety. The discriminator can eventually learn to reject the repeated dog, but then the generator tends to hop to a different narrow mode, and the chase continues without ever covering the whole dataset.

Researchers have proposed a long list of partial fixes, summarized below.

Technique	Year	Core idea	Source
Minibatch discrimination and related tricks	2016	Improved training procedures for GANs, tested on semi-supervised learning and realistic image generation	Salimans et al., arXiv:1606.03498
Unrolled GANs	2016	Base the generator's objective on several future discriminator updates, not just the current one, to counter mode collapse	Metz et al., arXiv:1611.02163
Wasserstein GAN	2017	Replace the original loss with a different distance between distributions, aiming for more stable training and useful learning curves	Arjovsky et al., arXiv:1701.07875
WGAN with gradient penalty	2017	Penalize the norm of the critic's gradient instead of clipping weights	Gulrajani et al., arXiv:1704.00028
Two time-scale update rule	2017	Give discriminator and generator separate learning rates, with a convergence proof	Heusel et al., arXiv:1706.08500
Spectral normalization	2018	A lightweight weight normalization that stabilizes the discriminator	Miyato et al., arXiv:1802.05957

The Wasserstein GAN paper claims it avoids mode collapse, but later practice showed that no technique removes the problem entirely. These methods reduce how often training fails. They do not make GAN training as forgiving as training an ordinary classifier.

A timeline of GAN milestones

The field moved fast between 2014 and 2019. The table dates the main steps using the arXiv submission dates.

Date	Milestone	What changed
June 10, 2014	Original GAN paper (Goodfellow et al.)	Adversarial training proposed; tested on MNIST, TFD, CIFAR-10
November 19, 2015	DCGAN (Radford, Metz, Chintala)	Convolutional architectures with specific design constraints made GANs a candidate for unsupervised feature learning
November 21, 2016	pix2pix (Isola et al.)	Conditional GANs as a general-purpose image-to-image translator
March 30, 2017	CycleGAN (Zhu et al.)	Translation without paired examples using a cycle consistency loss
October 27, 2017	ProGAN (Karras et al.)	Progressive growing; 1024 by 1024 pixel faces
September 28, 2018	BigGAN (Brock et al.)	Large-scale class-conditional synthesis on ImageNet
December 12, 2018	StyleGAN (Karras et al.)	Style-based generator; new face dataset
December 3, 2019	StyleGAN2 (Karras et al.)	Fixed characteristic image artifacts
March 9, 2023	GigaGAN (Kang et al.)	A GAN scaled to text-to-image synthesis

How StyleGAN reached photorealistic faces

By 2017, GAN faces were still obviously artificial: smeared textures, mismatched earrings, melting backgrounds. The jump came from NVIDIA researchers Tero Karras, Timo Aila, Samuli Laine, and Jaakko Lehtinen, in two steps.

Step one: grow the network as it learns

The ProGAN paper, submitted October 27, 2017, proposed training the generator and discriminator progressively. They start with tiny images and add layers that model finer details as training continues. The authors report this both speeds up and stabilizes training, and they used it to generate CelebA faces at 1024 by 1024 pixels. The reasoning is like teaching drawing: get the head's overall shape right on a small canvas before worrying about individual eyelashes. Coarse structure is learned early and cheaply, and fine detail is added later on top of a stable base.

Step two: control style at each scale

The StyleGAN paper, submitted December 12, 2018, borrowed an idea from style transfer. Instead of feeding the noise vector in at one end of the generator, StyleGAN first maps it to an intermediate representation and then injects it at every layer. The authors report that the architecture learns, without supervision, to separate high-level attributes such as pose and identity from stochastic variation such as freckles and hair placement. That separation is what makes controlled editing possible. If the idea of "style" in image generation interests you, Neural Style Transfer: How AI Learns to Remix Artistic Style covers the older technique it borrowed from.

The paper introduced a new face dataset, now known as FFHQ (Flickr-Faces-HQ). According to NVIDIA's repository, it contains 70,000 images at 1024 by 1024 resolution, crawled from Flickr and then automatically aligned and cropped, with people filtered out of statues, paintings, and photos of photos by crowd workers. A follow-up, StyleGAN2, submitted December 3, 2019, analyzed recurring visual artifacts in StyleGAN's output and fixed them with changes to the generator's normalization and a path length regularizer.

From research result to public demo

In February 2019, software engineer Phillip Wang launched thispersondoesnotexist.com, which served a fresh StyleGAN-generated face on every page load. Inverse reported that Wang shared the site in a Facebook group that week. In his words, he decided to "dig into my own pockets and raise some public awareness for this technology." It worked as a demonstration: most visitors had no easy way to tell.

Scale on ImageNet: BigGAN

Faces are a narrow domain, with aligned frontal views and consistent structure. Generating anything from an ImageNet class list is harder. In September 2018, Andrew Brock, Jeff Donahue, and Karen Simonyan reported that training GANs at larger scale, with an orthogonal regularization that enables a "truncation trick" for trading variety against fidelity, set a new state of the art. On ImageNet at 128 by 128 pixels, they reported an Inception Score of 166.5 and an FID of 7.4, compared with 52.52 and 18.6 for the previous best.

What GANs are used for beyond faces

Once the adversarial recipe was known, researchers applied it wherever "make this look like that" was the task.

Image-to-image translation

pix2pix (Isola et al., 2016) showed that a conditional GAN could serve as a general-purpose converter between image types: producing photos from segmentation layouts, objects from edge drawings, or color from grayscale. The generator receives an input image, not just noise, and the discriminator checks whether the output is a plausible match for it. The authors noted that many users adopted the released software for their own experiments with little tuning.

CycleGAN (Zhu et al., 2017) removed the need for paired examples. You may not have a photograph of the same scene in summer and winter, or a horse and zebra in identical poses. CycleGAN trains one mapping from domain X to Y and an inverse from Y back to X, and adds a cycle consistency loss that encourages translating there and back to return the starting image. In the paper's results this handled tasks such as style transfer, object transfiguration, season transfer, and photo enhancement.

Augmenting scarce data

Medical imaging often has too few examples of rare conditions. In a 2018 study, Maayan Frid-Adar and colleagues used GANs to generate synthetic CT liver lesion images for a dataset of 182 lesions (53 cysts, 64 metastases, and 65 hemangiomas). A classifier trained with classic augmentation alone reached 78.6% sensitivity and 88.4% specificity. Adding the GAN-generated images raised those to 85.7% and 92.4%. This is a single study on a small dataset, not proof that synthetic data always helps, but it shows the logic. When a model struggles with class imbalance, extra plausible examples of the rare class can help. For the metrics involved, see Why 99% Accuracy Can Be Useless: Precision and Recall, and for the broader practice, Synthetic Data Explained: Why AI Models Train on Artificial Data.

Fast simulation and privacy

The MIT Technology Review profile described two further ideas at the time. Researchers at Yale and Lawrence Berkeley National Laboratory built a GAN that predicts how particles behave, faster than conventional simulation. And Casey Greene of the University of Pennsylvania suggested GANs could create realistic fake patient records that could be shared while real records stay protected. Both illustrate the general pattern: where a slow or sensitive process can be approximated by a learned generator, a GAN offers a shortcut, though the approximation has to be validated against the real thing.

Deepfakes: what GANs did and did not do

GANs get the blame for deepfakes, and the truth is more specific. The original face-swapping tools that spread from late 2017, associated with a Reddit user who went by "deepfakes," did not use the adversarial game at their core. According to a 2020 survey by Yisroel Mirsky and Wenke Lee, this style of system uses one shared encoder and two decoders, trained concurrently as two autoencoders, one per identity. The encoder learns features common to both faces, such as pose and expression, and each decoder learns to render one specific person. To swap, you encode person A's face and decode it with person B's decoder.

An autoencoder is a network that compresses an input to a small code and reconstructs it, so it is trained to reproduce its input, not to fool a judge. Adversarial losses entered later. The same survey notes that tools such as DeepFaceLab offer adversarial training among their configuration options, and that FaceSwap-GAN follows a similar architecture while adding a GAN component. So the accurate statement is that GAN-style training improved face-swap realism and that GANs like StyleGAN enabled fully synthetic faces. The first wave of face-swap videos did not depend on them. For a broader look at the tools and detection, see What Are Deepfakes and How Do They Actually Work?

The harm is documented

A 2019 report by the security firm Deeptrace estimated that 96% of the deepfake videos it found online were pornographic. That figure describes one company's count at one time, so read it as a snapshot, not a current estimate. Non-consensual pornography is the clearest documented harm.

Can fakes be detected?

In a 2020 CVPR paper, Sheng-Yu Wang and colleagues built a dataset of images from 11 CNN-based generators and found that a standard classifier trained only on ProGAN images generalized well to unseen architectures, including StyleGAN2. They concluded that current CNN-generated images share common systematic flaws. The title carries its own warning: the images are "surprisingly easy to spot... for now." Detection is a moving target. A generator can be trained against a detector in the same way it is trained against a discriminator, so any fixed set of telltale artifacts has a limited lifespan. The more durable approaches change the question from "does this look fake?" to "where did this come from?", using provenance records created when a photo is captured.

GANs versus diffusion models

Diffusion models generate an image by starting with noise and removing it step by step, guided by a network trained to predict and subtract noise. They are the basis for most current text-to-image tools. AI Image Generators Explained and Generative AI Art: How Diffusion Models Actually Work cover that mechanism in detail.

The turning point in the research record is a May 2021 paper by Prafulla Dhariwal and Alex Nichol, titled "Diffusion Models Beat GANs on Image Synthesis." They reported FID scores of 2.97 on ImageNet at 128 by 128 pixels, 4.59 at 256 by 256, and 7.72 at 512 by 512, and said their models matched the BigGAN-deep model with as few as 25 forward passes per sample while covering the data distribution better.

Feature	GAN	Diffusion model
Training signal	Adversarial game between two networks	Learn to remove noise added to training images
Training stability	Sensitive; needs careful balancing	Generally more forgiving
Coverage of the data	Can suffer mode collapse	Reported to give better distribution coverage than BigGAN-deep (Dhariwal and Nichol, 2021)
Generation speed	One forward pass per image	Many steps unless distilled
Text prompt control	Possible but harder to scale	The standard approach today

Speed is where GANs still win

A GAN produces an image in one pass through the generator. Diffusion models traditionally need dozens of steps. In March 2023, the GigaGAN paper reported a GAN scaled for text-to-image synthesis that took 0.13 seconds to synthesize a 512 pixel image, and noted that naively enlarging StyleGAN had become unstable. The authors framed it as an answer to the question of whether GANs could still scale to huge datasets.

Adversarial ideas moved into diffusion

The adversarial game did not disappear. It found a new job. In November 2023, Axel Sauer and colleagues published Adversarial Diffusion Distillation, a method that combines distillation from a diffusion model with an adversarial loss to produce images in one to four steps. The authors report it outperforms GANs and Latent Consistency Models in a single step and matches SDXL in four. In other words, a discriminator is now used to keep a fast diffusion model sharp. If you want a general explanation of distillation, see AI Model Distillation Explained.

What people get wrong about GANs

"The generator copies training images." It does not see them. It only receives the discriminator's judgments, though in practice a generator that overfits can reproduce training examples closely, and that is a failure to be tested for, not the design.

"At equilibrium, the GAN has learned the true distribution." That holds in the idealized proof. In practice, training often oscillates and never reaches a clean equilibrium, which is why the Lucic study found hyperparameter tuning mattered as much as the algorithm.

"A low generator loss means good images." The two losses are coupled. Judging a GAN requires looking at samples and using metrics such as FID, with their known limits.

"Deepfakes are GANs." Original face-swapping tools used autoencoders, with GANs as an optional later refinement.

"Diffusion models made GANs obsolete." They displaced GANs for flagship text-to-image products. GANs remain relevant where one-pass speed matters, and adversarial losses are used inside newer methods.

What this means

The GAN's core contribution was not an architecture but an idea: you can train a generator without defining quality by hand, if you give it an opponent that learns the definition. That idea produced the first convincing synthetic faces and a wave of image translation tools, and it also produced a notoriously temperamental training process. The same property that made it powerful, a moving target that improves with the player, is what made it hard to stabilize.

Today the practical lesson is about trade-offs. Diffusion models are easier to train and to steer with text, and GANs are fast. The strongest recent work borrows from both. For readers trying to judge an image, the 2019 to 2023 record also shows that appearance is a weak guide: the quality of generated faces passed the point where casual inspection works years ago.

Key takeaways

• A GAN pits a generator (producing fakes from noise) against a discriminator (scoring real versus fake) in a minimax game introduced on June 10, 2014.
• In theory the generator's distribution matches the data when the discriminator outputs 1/2 everywhere. In practice, training rarely reaches that clean state.
• Training instability and mode collapse are the central failure modes. Fixes such as WGAN, gradient penalty, spectral normalization, and separate learning rates reduce them without eliminating them.
• ProGAN and StyleGAN reached photorealistic 1024 by 1024 pixel faces through progressive growing and a style-based generator.
• Early deepfake face swaps used autoencoders, not GANs. Adversarial training was added later.
• Diffusion models overtook GANs in image quality benchmarks in 2021, but GANs remain much faster, and adversarial losses now appear in distilled diffusion models.

FAQ

Q: Who invented GANs and when? A: Ian Goodfellow and colleagues, including Yoshua Bengio and Aaron Courville, posted the paper to arXiv on June 10, 2014. According to MIT Technology Review, the idea came to Goodfellow at a Montreal pub, and he coded a first version at home that night.

Q: How is a GAN different from a variational autoencoder (VAE)? A: A VAE compresses data into a latent code and learns to reconstruct it, and it is trained with an explicit probabilistic objective. A GAN has no reconstruction target for the generator and learns only from a discriminator's feedback. In the 2014 paper, the authors listed the lack of an explicit representation of the generator's distribution as a disadvantage of the approach.

Q: Can you detect GAN-generated images? A: Often, for now. A 2020 CVPR study found a classifier trained only on ProGAN images generalized to other generators, including StyleGAN2, because CNN-generated images share systematic flaws. Detectors can be defeated by newer generators, so no detector is permanent.

Q: What is a conditional GAN? A: A conditional GAN feeds extra information, such as a class label or an input image, to both networks so the output is tied to that condition. pix2pix is an example: it uses conditional adversarial networks to convert one kind of image into another, such as edge drawings into objects.

Q: Is mode collapse solved? A: No. Unrolled GANs, Wasserstein GANs, minibatch techniques, and other methods reduce it, but none has removed it completely. The 2014 paper already named the related Helvetica scenario as a risk when the generator is trained too far ahead of the discriminator.

Q: What happened to GANs after diffusion models arrived? A: Diffusion models took over text-to-image generation after outscoring the leading GAN on ImageNet benchmarks in 2021. GANs stayed useful where speed matters, and a 2023 GigaGAN paper reported 0.13 seconds for a 512 pixel image. Adversarial losses also now sharpen fast, distilled diffusion models.

Q: Why is GAN training called unstable? A: Because two networks update against each other, each change moves the other's target. If the discriminator wins too easily, the generator gets weak gradients. If the generator pulls ahead, it can collapse onto a few outputs. A 2017 large-scale study found results depended heavily on tuning and restarts.

Sources

• Goodfellow et al., "Generative Adversarial Networks," arXiv, June 10, 2014: arxiv.org/abs/1406.2661
• MIT Technology Review, "The GANfather" (2018): technologyreview.com
• Karras et al., "Progressive Growing of GANs": arxiv.org/abs/1710.10196
• Karras et al., "A Style-Based Generator Architecture for GANs": arxiv.org/abs/1812.04948
• Karras et al., "Analyzing and Improving the Image Quality of StyleGAN": arxiv.org/abs/1912.04958
• NVIDIA FFHQ dataset: github.com/NVlabs/ffhq-dataset
• Brock et al., "Large Scale GAN Training for High Fidelity Natural Image Synthesis": arxiv.org/abs/1809.11096
• Dhariwal and Nichol, "Diffusion Models Beat GANs on Image Synthesis": arxiv.org/abs/2105.05233
• Lucic et al., "Are GANs Created Equal?": arxiv.org/abs/1711.10337
• Heusel et al., TTUR and FID: arxiv.org/abs/1706.08500
• Arjovsky et al., "Wasserstein GAN": arxiv.org/abs/1701.07875
• Mirsky and Lee, "The Creation and Detection of Deepfakes: A Survey": arxiv.org/abs/2004.11138
• Wang et al., "CNN-generated images are surprisingly easy to spot... for now": arxiv.org/abs/1912.11035
• Frid-Adar et al., GAN-based liver lesion augmentation: arxiv.org/abs/1803.01229
• Kang et al., "Scaling up GANs for Text-to-Image Synthesis" (GigaGAN): arxiv.org/abs/2303.05511
• Sauer et al., "Adversarial Diffusion Distillation": arxiv.org/abs/2311.17042

---

Read next:

• How Do Neural Networks Work? The Architecture Behind Modern AI
• How Image Recognition Works: The Science of Convolutional Neural Networks
• Edge AI: How AI Runs on Your Phone