PyTorch-GAN

PyTorch implementations of Generative Adversarial Networks.

16,335

4,067

16,335

141

View on GitHub

Top Related Projects

pytorch-CycleGAN-and-pix2pix

22,900

Image-to-Image Translation in PyTorch

ganhacks

11,442

starter from "How to Train a GAN?" at NIPS2016

improved-gan

2,282

Code for the paper "Improved Techniques for Training GANs"

DCGAN-tensorflow

7,146

A tensorflow implementation of "Deep Convolutional Generative Adversarial Networks"

Quick Overview

PyTorch-GAN is a collection of PyTorch implementations of Generative Adversarial Network (GAN) architectures and variants. It provides a comprehensive set of GAN models, including popular architectures like DCGAN, WGAN, and CycleGAN, among others. The repository serves as a valuable resource for researchers and practitioners working with GANs in PyTorch.

Pros

Extensive collection of GAN implementations in PyTorch
Well-organized codebase with consistent structure across models
Includes both simple and advanced GAN architectures
Provides training scripts and example outputs for each model

Cons

Some implementations may not be optimized for the latest PyTorch versions
Limited documentation for some of the more complex models
Lack of pre-trained models or weights for immediate use
Some models may require significant computational resources to train

Code Examples

Importing and initializing a DCGAN model:

from models import dcgan

# Initialize generator and discriminator
generator = dcgan.Generator()
discriminator = dcgan.Discriminator()

Training loop for a basic GAN:

for epoch in range(n_epochs):
    for i, (imgs, _) in enumerate(dataloader):
        # Train Discriminator
        real_loss = adversarial_loss(discriminator(real_imgs), valid)
        fake_loss = adversarial_loss(discriminator(gen_imgs.detach()), fake)
        d_loss = (real_loss + fake_loss) / 2

        # Train Generator
        g_loss = adversarial_loss(discriminator(gen_imgs), valid)

        # Optimize
        optimizer_G.step()
        optimizer_D.step()

Generating images with a trained GAN:

# Generate a batch of images
z = torch.randn(batch_size, latent_dim)
gen_imgs = generator(z)

# Save generated images
save_image(gen_imgs.data[:25], "generated_images.png", nrow=5, normalize=True)

Getting Started

Clone the repository:

git clone https://github.com/eriklindernoren/PyTorch-GAN.git
cd PyTorch-GAN

Install dependencies:
```
pip install -r requirements.txt
```

Run a specific GAN implementation:

cd implementations/dcgan
python3 dcgan.py

This will train a DCGAN on the MNIST dataset and save generated images in the images/ directory.

Competitor Comparisons

pytorch-CycleGAN-and-pix2pix

22,900

Image-to-Image Translation in PyTorch

Pros of pytorch-CycleGAN-and-pix2pix

Focuses on specific GAN architectures (CycleGAN and pix2pix), providing in-depth implementations and optimizations
Includes pre-trained models and datasets, making it easier to get started and reproduce results
Offers a more comprehensive documentation and usage guide

Cons of pytorch-CycleGAN-and-pix2pix

Limited to CycleGAN and pix2pix architectures, while PyTorch-GAN covers a wider range of GAN models
May have a steeper learning curve for beginners due to its more specialized nature

Code Comparison

PyTorch-GAN:

def forward(self, img):
    validity = self.model(img)
    return validity

pytorch-CycleGAN-and-pix2pix:

def forward(self, input):
    return self.model(input)

Both repositories use similar forward pass implementations, but pytorch-CycleGAN-and-pix2pix tends to have more complex model architectures and training loops due to its specialized focus on CycleGAN and pix2pix.

PyTorch-GAN provides a broader range of GAN implementations, making it suitable for exploring various architectures. In contrast, pytorch-CycleGAN-and-pix2pix offers a more in-depth implementation of specific GAN models, with additional features like pre-trained models and datasets.

ganhacks

11,442

starter from "How to Train a GAN?" at NIPS2016

Pros of ganhacks

Focuses on practical tips and tricks for training GANs
Provides a concise list of best practices for GAN implementation
Language-agnostic advice applicable to various frameworks

Cons of ganhacks

Lacks actual code implementations
Not actively maintained (last update in 2017)
Limited to general guidelines without specific examples

Code comparison

PyTorch-GAN provides complete implementations, while ganhacks offers no code. An example from PyTorch-GAN:

class Generator(nn.Module):
    def __init__(self):
        super(Generator, self).__init__()
        self.init_size = opt.img_size // 4
        self.l1 = nn.Sequential(nn.Linear(opt.latent_dim, 128*self.init_size**2))
        # ... (more layers)

ganhacks provides conceptual advice instead:

# Pseudocode representation of a tip
if training_instability:
    use_historical_averaging()

PyTorch-GAN offers a comprehensive collection of GAN implementations in PyTorch, while ganhacks provides general guidelines for improving GAN performance across different frameworks. PyTorch-GAN is more suitable for those seeking ready-to-use code, while ganhacks is beneficial for understanding GAN training principles.

the-gan-zoo

14,208

A list of all named GANs!

Pros of the-gan-zoo

Comprehensive list of GAN variants with links to papers and code
Regularly updated with new GAN architectures
Serves as a valuable reference for researchers and practitioners

Cons of the-gan-zoo

No implementation code provided, only links to external resources
Less focused on practical usage compared to PyTorch-GAN
May be overwhelming for beginners due to the sheer number of GAN variants listed

Code comparison

PyTorch-GAN provides implementation code for various GAN architectures:

class Generator(nn.Module):
    def __init__(self):
        super(Generator, self).__init__()
        self.model = nn.Sequential(
            # Generator architecture
        )

the-gan-zoo doesn't provide code implementations, but rather links to external repositories:

| Adversarial Autoencoders | [arxiv](https://arxiv.org/abs/1511.05644) | [code](https://github.com/musyoku/adversarial-autoencoder) |
| Adversarial Variational Bayes | [arxiv](https://arxiv.org/abs/1701.04722) | [code](https://github.com/LMescheder/AdversarialVariationalBayes) |

The main difference is that PyTorch-GAN offers ready-to-use implementations, while the-gan-zoo serves as a comprehensive directory of GAN variants with links to external resources.

improved-gan

2,282

Code for the paper "Improved Techniques for Training GANs"

Pros of improved-gan

Focuses on advanced GAN techniques like feature matching and minibatch discrimination
Implements the improved Wasserstein GAN (WGAN-GP) algorithm
Provides a more research-oriented approach with detailed explanations

Cons of improved-gan

Limited variety of GAN architectures compared to PyTorch-GAN
Less beginner-friendly, with fewer examples and documentation
Primarily uses TensorFlow, which may not be preferred by PyTorch users

Code Comparison

improved-gan (TensorFlow):

def discriminator(x):
    output = lib.ops.linear.Linear('Discriminator.Input', 784, 1024, x)
    output = LeakyReLU(output)
    output = lib.ops.linear.Linear('Discriminator.2', 1024, 1024, output)
    output = LeakyReLU(output)
    output = lib.ops.linear.Linear('Discriminator.3', 1024, 1, output)
    return output

PyTorch-GAN:

class Discriminator(nn.Module):
    def __init__(self):
        super(Discriminator, self).__init__()
        self.model = nn.Sequential(
            nn.Linear(784, 1024),
            nn.LeakyReLU(0.2, inplace=True),
            nn.Linear(1024, 1024),
            nn.LeakyReLU(0.2, inplace=True),
            nn.Linear(1024, 1),
        )

DCGAN-tensorflow

7,146

A tensorflow implementation of "Deep Convolutional Generative Adversarial Networks"

Pros of DCGAN-tensorflow

Focuses specifically on Deep Convolutional GANs (DCGANs), providing a more specialized implementation
Uses TensorFlow, which may be preferred by some developers and researchers
Includes pre-trained models for quick experimentation

Cons of DCGAN-tensorflow

Limited to DCGAN architecture, while PyTorch-GAN offers multiple GAN variants
Less actively maintained, with fewer recent updates compared to PyTorch-GAN
Lacks the extensive documentation and examples found in PyTorch-GAN

Code Comparison

DCGAN-tensorflow:

def discriminator(image, reuse=False):
    with tf.variable_scope("discriminator") as scope:
        if reuse:
            scope.reuse_variables()
        # Discriminator implementation

PyTorch-GAN:

class Discriminator(nn.Module):
    def __init__(self):
        super(Discriminator, self).__init__()
        # Discriminator implementation

The DCGAN-tensorflow repository uses TensorFlow's lower-level API with explicit variable scopes, while PyTorch-GAN utilizes PyTorch's higher-level nn.Module class for defining the discriminator. This difference reflects the distinct approaches of the two frameworks, with PyTorch offering a more object-oriented and Pythonic style.

Convert designs to code with AI

Introducing Visual Copilot: A new AI model to turn Figma designs to high quality code using your components.

Try Visual Copilot

README

This repository has gone stale as I unfortunately do not have the time to maintain it anymore. If you would like to continue the development of it as a collaborator send me an email at eriklindernoren@gmail.com.

PyTorch-GAN

Collection of PyTorch implementations of Generative Adversarial Network varieties presented in research papers. Model architectures will not always mirror the ones proposed in the papers, but I have chosen to focus on getting the core ideas covered instead of getting every layer configuration right. Contributions and suggestions of GANs to implement are very welcomed.

See also: Keras-GAN

Installation
Implementations

Installation

$ git clone https://github.com/eriklindernoren/PyTorch-GAN
$ cd PyTorch-GAN/
$ sudo pip3 install -r requirements.txt

Implementations

Auxiliary Classifier GAN

Auxiliary Classifier Generative Adversarial Network

Authors

Augustus Odena, Christopher Olah, Jonathon Shlens

Abstract

Synthesizing high resolution photorealistic images has been a long-standing challenge in machine learning. In this paper we introduce new methods for the improved training of generative adversarial networks (GANs) for image synthesis. We construct a variant of GANs employing label conditioning that results in 128x128 resolution image samples exhibiting global coherence. We expand on previous work for image quality assessment to provide two new analyses for assessing the discriminability and diversity of samples from class-conditional image synthesis models. These analyses demonstrate that high resolution samples provide class information not present in low resolution samples. Across 1000 ImageNet classes, 128x128 samples are more than twice as discriminable as artificially resized 32x32 samples. In addition, 84.7% of the classes have samples exhibiting diversity comparable to real ImageNet data.

Method	Accuracy
Naive	55%
PixelDA	95%

Top Related Projects

Quick Overview

Pros

Cons

Code Examples

Getting Started

Competitor Comparisons

Pros of pytorch-CycleGAN-and-pix2pix

Cons of pytorch-CycleGAN-and-pix2pix

Code Comparison

Pros of ganhacks

Cons of ganhacks

Code comparison

Pros of the-gan-zoo

Cons of the-gan-zoo

Code comparison

Pros of improved-gan

Cons of improved-gan

Code Comparison

Pros of DCGAN-tensorflow

Cons of DCGAN-tensorflow

Code Comparison

Convert designs to code with AI

README

PyTorch-GAN

Table of Contents

Installation

Implementations

Auxiliary Classifier GAN

Authors

Abstract

Run Example

Adversarial Autoencoder

Authors

Abstract

Run Example

BEGAN

Authors

Abstract

Run Example

BicycleGAN

Authors

Abstract

Run Example

Boundary-Seeking GAN

Authors

Abstract

Run Example

Cluster GAN

Authors

Abstract

Run Example

Conditional GAN

Authors

Abstract

Run Example

Context-Conditional GAN

Authors

Abstract

Run Example

Context Encoder

Authors

Abstract

Run Example

Coupled GAN

Authors

Abstract

Run Example

CycleGAN

Authors

Abstract

Run Example

Deep Convolutional GAN

Authors

Abstract

Run Example

DiscoGAN

Authors

Abstract

Run Example