├── .github └── FUNDING.yml ├── .gitignore ├── LICENCE ├── README.md ├── Vanilla GAN (PyTorch).ipynb ├── data └── examples │ ├── generated_samples │ ├── generated_dcgan.jpg │ └── generated_vgan.jpg │ ├── intermediate_imagery.PNG │ ├── interpolation │ ├── dcgan_interpolated.jpg │ ├── slerp.png │ └── vgan_interpolated.jpg │ ├── jupyter │ ├── cross_entropy_loss.png │ └── data_distribution.PNG │ ├── losses.PNG │ ├── real_samples │ ├── celeba.jpg │ └── mnist.jpg │ ├── training_progress │ ├── training_progress_cgan.gif │ ├── training_progress_dcgan.gif │ └── training_progress_vgan.gif │ └── vector_arithmetic │ └── vector_arithmetic.jpg ├── environment.yml ├── generate_imagery.py ├── models ├── binaries │ ├── CGAN_000000.pth │ ├── DCGAN_000000.pth │ └── VANILLA_000000.pth └── definitions │ ├── conditional_gan.py │ ├── dcgan.py │ └── vanilla_gan.py ├── playground.py ├── train_cgan.py ├── train_dcgan.py ├── train_vanilla_gan.py └── utils ├── constants.py ├── utils.py └── video_utils.py /.github/FUNDING.yml: -------------------------------------------------------------------------------- 1 | patreon: theaiepiphany 2 | -------------------------------------------------------------------------------- /.gitignore: -------------------------------------------------------------------------------- 1 | .idea 2 | __pycache__ 3 | 4 | .ipynb_checkpoints 5 | 6 | runs 7 | 8 | models/binaries 9 | models/checkpoints 10 | 11 | data/interpolated_imagery 12 | data/generated_imagery 13 | data/debug_imagery 14 | data/MNIST 15 | data/CelebA -------------------------------------------------------------------------------- /LICENCE: -------------------------------------------------------------------------------- 1 | MIT License 2 | 3 | Copyright (c) 2020 Aleksa Gordić 4 | 5 | Permission is hereby granted, free of charge, to any person obtaining a copy 6 | of this software and associated documentation files (the "Software"), to deal 7 | in the Software without restriction, including without limitation the rights 8 | to use, copy, modify, merge, publish, distribute, sublicense, and/or sell 9 | copies of the Software, and to permit persons to whom the Software is 10 | furnished to do so, subject to the following conditions: 11 | 12 | The above copyright notice and this permission notice shall be included in all 13 | copies or substantial portions of the Software. 14 | 15 | THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR 16 | IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, 17 | FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE 18 | AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER 19 | LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, 20 | OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE 21 | SOFTWARE. -------------------------------------------------------------------------------- /README.md: -------------------------------------------------------------------------------- 1 | ## PyTorch GANs :computer: vs :computer: = :heart: 2 | This repo contains PyTorch implementation of various GAN architectures.
3 | It's aimed at making it **easy for beginners** to start playing and learning about GANs.
4 | 5 | All of the repos I found do obscure things like setting bias in some network layer to `False` without explaining
6 | why certain design decisions were made. This repo makes **every design decision transparent.** 7 | 8 | ## Table of Contents 9 | * [What are GANs?](#what-are-gans) 10 | * [Setup](#setup) 11 | * [Implementations](#implementations) 12 | + [Vanilla GAN](#vanilla-gan) 13 | + [Conditional GAN](#conditional-gan) 14 | + [DCGAN](#dcgan) 15 | 16 | ## What are GANs? 17 | 18 | GANs were originally proposed by Ian Goodfellow et al. in a seminal paper called [Generative Adversarial Nets](https://papers.nips.cc/paper/5423-generative-adversarial-nets.pdf). 19 | 20 | GANs are a framework where 2 models (usually neural networks), called generator (G) and discriminator (D), play a **minimax game** against each other. 21 | The generator is trying to **learn the distribution of real data** and is the network which we're usually interested in. 22 | During the game the goal of the generator is to trick the discriminator into "thinking" that the data it generates is real. 23 | The goal of the discriminator, on the other hand, is to correctly discriminate between the generated (fake) images and real images coming from some dataset (e.g. MNIST). 24 | 25 | ## Setup 26 | 27 | 1. `git clone https://github.com/gordicaleksa/pytorch-gans` 28 | 2. Open Anaconda console and navigate into project directory `cd path_to_repo` 29 | 3. Run `conda env create` from project directory (this will create a brand new conda environment). 30 | 4. Run `activate pytorch-gans` (for running scripts from your console or set the interpreter in your IDE) 31 | 32 | That's it! It should work out-of-the-box executing environment.yml file which deals with dependencies. 33 | 34 | ----- 35 | 36 | PyTorch package will pull some version of CUDA with it, but it is highly recommended that you install system-wide CUDA beforehand, mostly because of GPU drivers. I also recommend using Miniconda installer as a way to get conda on your system. 37 | 38 | Follow through points 1 and 2 of [this setup](https://github.com/Petlja/PSIML/blob/master/docs/MachineSetup.md) and use the most up-to-date versions of Miniconda and CUDA/cuDNN. 39 | 40 | ## Implementations 41 | 42 | Important note: you don't need to train the GANs to use this project I've checked-in pre-trained models.
43 | You can just use the `generate_imagery.py` script to play with the models. 44 | 45 | ## Vanilla GAN 46 | 47 | Vanilla GAN is my implementation of the [original GAN paper (Goodfellow et al.)](https://papers.nips.cc/paper/5423-generative-adversarial-nets.pdf) with certain modifications mostly in the model architecture, 48 | like the usage of LeakyReLU and 1D batch normalization (it didn't even exist back then) instead of the maxout activation and dropout. 49 | 50 | ### Examples 51 | 52 | GAN was trained on data from MNIST dataset. Here is how the digits from the dataset look like: 53 | 54 |

55 | 56 |

57 | 58 | You can see how the network is slowly learning to capture the data distribution during training: 59 | 60 |

61 | 62 |

63 | 64 | After the generator is trained we can use it to generate all 10 digits! Looks like it's coming directly from MNIST, right!? 65 | 66 |

67 | 68 |

69 | 70 | We can also pick 2 generated numbers that we like, save their latent vectors, and subsequently [linearly](https://en.wikipedia.org/wiki/Linear_interpolation) or [spherically](https://en.wikipedia.org/wiki/Slerp)
71 | interpolate between them to generate new images and understand how the latent space (z-space) is structured: 72 | 73 |

74 | 75 |

76 | 77 | We can see how the number 4 is slowly morphing into 9 and then into the number 3.
78 | 79 | The idea behind spherical interpolation is super easy - instead of moving over the shortest possible path
80 | (line i.e. linear interpolation) from the first vector (p0) to the second (p1), you take the sphere's arc path: 81 | 82 |

83 | 84 |

85 | 86 | ### Usage 87 | 88 | #### Option 1: Jupyter Notebook 89 | 90 | Just run `jupyter notebook` from you Anaconda console and it will open the session in your default browser.
91 | Open `Vanilla GAN (PyTorch).py` and you're ready to play!
92 | 93 | If you created the env before I added jupyter just do `pip install jupyter==1.0.0` and you're ready. 94 | 95 | --- 96 | 97 | **Note:** if you get `DLL load failed while importing win32api: The specified module could not be found`
98 | Just do `pip uninstall pywin32` and then either `pip install pywin32` or `conda install pywin32` [should fix it](https://github.com/jupyter/notebook/issues/4980)! 99 | 100 | #### Option 2: Use your IDE of choice 101 | 102 | #### Training 103 | 104 | It's really easy to kick-off new training just run this:
105 | `python train_vanilla_gan.py --batch_size ` 106 | 107 | The code is well commented so you can exactly understand how the training itself works.
108 | 109 | The script will: 110 | * Dump checkpoint *.pth models into `models/checkpoints/` 111 | * Dump the final *.pth model into `models/binaries/` 112 | * Dump intermediate generated imagery into `data/debug_imagery/` 113 | * Download MNIST (~100 MB) the first time you run it and place it into `data/MNIST/` 114 | * Dump tensorboard data into `runs/`, just run `tensorboard --logdir=runs` from your Anaconda 115 | 116 | And that's it you can track the training both visually (dumped imagery) and through G's and D's loss progress. 117 | 118 |

119 | 120 | 121 |

122 | 123 | Tracking loss can be helpful but I mostly relied on visually analyzing intermediate imagery.
124 | 125 | Note1: also make sure to check out **playground.py** file if you're having problems understanding adversarial loss.
126 | Note2: Images are dumped both to the file system `data/debug_imagery/` but also to tensorboard. 127 | 128 | #### Generating imagery and interpolating 129 | 130 | To generate a single image just run the script with defaults:
131 | `python generate_imagery.py` 132 | 133 | It will display and dump the generated image into `data/generated_imagery/` using checked-in generator model.
134 | 135 | Make sure to change the `--model_name` param to your model's name (once you train your own model).
136 | 137 | ----- 138 | 139 | If you want to play with interpolation, just set the `--generation_mode` to `GenerationMode.INTERPOLATION`.
140 | And optionally set `--slerp` to true if you want to use spherical interpolation. 141 | 142 | The first time you run it in this mode the script will start generating images,
143 | and ask you to pick 2 images you like by entering `'y'` into the console. 144 | 145 | Finally it will start displaying interpolated imagery and dump the results to `data/interpolated_imagery`. 146 | 147 | ## Conditional GAN 148 | 149 | Conditional GAN (cGAN) is my implementation of the [cGAN paper (Mehdi et al.)](https://arxiv.org/pdf/1411.1784.pdf).
150 | It basically just adds conditioning vectors (one hot encoding of digit labels) to the vanilla GAN above. 151 | 152 | ### Examples 153 | 154 | In addition to everything that we could do with the original GAN, here we can exactly control which digit we want to generate! 155 | We make it dump 10x10 grid where each column is a single digit and this is how the learning proceeds: 156 | 157 |

158 | 159 |

160 | 161 | ### Usage 162 | 163 | For training just check out [vanilla GAN](#training) (just make sure to use `train_cgan.py` instead). 164 | 165 | #### Generating imagery 166 | 167 | Same as for [vanilla GAN](#generating-imagery-and-interpolating) but you can additionally set `cgan_digit` to a number between 0 and 9 to generate that exact digit! 168 | There is no interpolation support for cGAN, it's the same as for vanilla GAN feel free to use that. 169 | 170 | Note: make sure to set `--model_name` to either `CGAN_000000.pth` (pre-trained and checked-in) or your own model. 171 | 172 | ## DCGAN 173 | 174 | DCGAN is my implementation of the [DCGAN paper (Radford et al.)](https://arxiv.org/pdf/1511.06434.pdf).
175 | The main contribution of the paper was that they were the first who made CNNs successfully work in the GAN setup.
176 | Batch normalization was invented in the meanwhile and that's what got CNNs to work basically. 177 | 178 | ### Examples 179 | 180 | I trained DCGAN on preprocessed [CelebA dataset](http://mmlab.ie.cuhk.edu.hk/projects/CelebA.html). Here are some samples from the dataset: 181 | 182 |

183 | 184 |

185 | 186 | Again, you can see how the network is slowly learning to capture the data distribution during training: 187 | 188 |

189 | 190 |

191 | 192 | After the generator is trained we can use it to generate new faces! This problem is much harder than generating MNIST digits, 193 | so generated faces are not indistinguishable from the real ones. 194 | 195 |

196 | 197 |

198 | 199 | Some SOTA GAN papers did a much better job at generating faces, currently the best model is [StyleGAN2](https://github.com/NVlabs/stylegan2). 200 | 201 | Similarly we can explore the structure of the latent space via interpolations: 202 | 203 |

204 | 205 |

206 | 207 | We can see how the man's face is slowly morphing into woman's face and also the skin tan is changing gradually. 208 | 209 | Finally, because the latent space has some nice properties (linear structure) we can do some interesting things.
210 | Subtracting neutral woman's latent vector from smiling woman's latent vector gives us the "smile vector".
211 | Adding that vector to neutral man's latent vector, we hopefully get smiling man's latent vector. And so it is! 212 | 213 |

214 | 215 |

216 | 217 | You can also create the "sunglasses vector" and use it to add sunglasses to other faces, etc. 218 | 219 | *Note: I've created an interactive script so you can play with this check out `GenerationMode.VECTOR_ARITHMETIC`.* 220 | 221 | ### Usage 222 | 223 | For training just check out [vanilla GAN](#training) (just make sure to use `train_dcgan.py` instead).
224 | The only difference is that this script will download [pre-processed CelebA dataset](https://s3.amazonaws.com/video.udacity-data.com/topher/2018/November/5be7eb6f_processed-celeba-small/processed-celeba-small.zip) instead of MNIST. 225 | 226 | #### Generating imagery 227 | 228 | Again just use the `generate_imagery.py` script. 229 | 230 | You have 3 options you can set the `generation_mode` to: 231 | * `GenerationMode.SINGLE_IMAGE` <- generate a single face image 232 | * `GenerationMode.INTERPOLATION` <- pick 2 face images you like and script will interpolate between them 233 | * `GenerationMode.VECTOR_ARITHMETIC` <- pick 9 images and script will do vector arithmetic 234 | 235 | GenerationMode.VECTOR_ARITHMETIC will give you an **interactive matplotlib plot** to pick 9 images. 236 | 237 | Note: make sure to set `--model_name` to either `DCGAN_000000.pth` (pre-trained and checked-in) or your own model. 238 | 239 | ## Acknowledgements 240 | 241 | I found these repos useful (while developing this one): 242 | * [gans](https://github.com/diegoalejogm/gans) (PyTorch & TensorFlow) 243 | * [PyTorch-GAN](https://github.com/eriklindernoren/PyTorch-GAN) (PyTorch) 244 | 245 | ## Citation 246 | 247 | If you find this code useful for your research, please cite the following: 248 | 249 | ``` 250 | @misc{Gordić2020PyTorchGANs, 251 | author = {Gordić, Aleksa}, 252 | title = {pytorch-gans}, 253 | year = {2020}, 254 | publisher = {GitHub}, 255 | journal = {GitHub repository}, 256 | howpublished = {\url{https://github.com/gordicaleksa/pytorch-gans}}, 257 | } 258 | ``` 259 | 260 | ## Connect with me 261 | 262 | If you'd love to have some more AI-related content in your life :nerd_face:, consider: 263 | * Subscribing to my YouTube channel [The AI Epiphany](https://www.youtube.com/c/TheAiEpiphany) :bell: 264 | * Follow me on [LinkedIn](https://www.linkedin.com/in/aleksagordic/) and [Twitter](https://twitter.com/gordic_aleksa) :bulb: 265 | * Follow me on [Medium](https://gordicaleksa.medium.com/) :books: :heart: 266 | 267 | ## Licence 268 | 269 | [![License: MIT](https://img.shields.io/badge/License-MIT-yellow.svg)](https://github.com/gordicaleksa/pytorch-gans/blob/master/LICENCE) -------------------------------------------------------------------------------- /Vanilla GAN (PyTorch).ipynb: -------------------------------------------------------------------------------- 1 | { 2 | "cells": [ 3 | { 4 | "cell_type": "markdown", 5 | "metadata": {}, 6 | "source": [ 7 | "# Ultimate beginner's guide to GANs 👨🏽‍💻\n", 8 | "\n", 9 | "In this notebook you'll learn:\n", 10 | "\n", 11 | "✅ What are GANs exactly?
\n", 12 | "✅ How to train them?
\n", 13 | "✅ How to use them?
\n", 14 | "\n", 15 | "After you complete this one you'll have a much better understanding of GANs!\n", 16 | "\n", 17 | "So, let's start!\n", 18 | "\n", 19 | "---\n", 20 | "\n", 21 | "## What the heck are GANs and how they came to be?\n", 22 | "\n", 23 | "GANs were originally proposed by Ian Goodfellow et al. in a seminal paper called [Generative Adversarial Nets](https://papers.nips.cc/paper/5423-generative-adversarial-nets.pdf).\n", 24 | "\n", 25 | "(`et al.` - fancy Latin phrase you'll be seing around it means `and others`)\n", 26 | "\n", 27 | "You DON'T need to understand the paper in order to understand this notebook. That being said:\n", 28 | "\n", 29 | "---\n", 30 | "\n", 31 | "GANs are a `framework` where 2 models (usually `neural networks`), called `generator (G)` and `discriminator (D)`, play a `minimax game` against each other. The generator is trying to learn the `distribution of real data` and is the network which we're usually interested in. During the game the goal of the generator is to trick the discriminator into \"thinking\" that the images it generates is real. The goal of the discriminator, on the other hand, is to correctly discriminate between the generated (fake) images and real images coming from some dataset (e.g. MNIST). \n", 32 | "\n", 33 | "At the equilibrium of the game the generator learns to generate images indistinguishable from the real images and the best that discriminator can do is output 0.5 - meaning it's 50% sure that what you gave him is a real image (and 50% sure that it's fake) - i.e. it doesn't have a clue of what's happening!\n", 34 | "\n", 35 | "Potentially confusing parts:

\n", 36 | "`minimax game` - basically they have some goal (objective function) and one is trying to minimize it, the other to maximize it, that's it.

\n", 37 | "`distribution of real data` - basically you can think of any data you use as a point in the `n-dimensional` space. For example, MNIST 28x28 image when flattened has 784 numbers. So 1 image is simply a point in the 784-dimensional space. That's it. when I say `n` in order to visualize it just think of `3` or `2` dimensions - that's how everybody does it. So you can think of your data as a 3D/2D cloud of points. Each point has some probability associated with it - how likely is it to appear - that's the `distribution` part. So if your model has internal representation of this 3D/2D point cloud there is nothing stopping it from generating more points from that cloud! And those are new images (be it human faces, digits or whatever) that never existed!\n", 38 | "\n", 39 | " $\"example$
\n", 40 | "\n", 41 | "Here is an example of a simple data distribution. The data here is 2-dimensional and the height of the plot is the probability of certain datapoint appearing. You can see that points around (0, 0) have the highest probability of happening. Those datapoints could be your 784-dimensional images projected into 2-dimensional space via PCA, t-SNE, UMAP, etc. (you don't need to know what these are, they are just some dimensionality reduction methods out there).\n", 42 | "\n", 43 | "In reality this plot would have multiple peaks (`multi-modal`) and wouldn't be this nice.\n", 44 | "\n", 45 | "\n", 46 | "---\n", 47 | "\n", 48 | "That was everything you need to know for now as a beginner! Let's code!\n", 49 | "\n" 50 | ] 51 | }, 52 | { 53 | "cell_type": "code", 54 | "execution_count": 1, 55 | "metadata": {}, 56 | "outputs": [], 57 | "source": [ 58 | "# I always like to structure my imports into Python's native libs,\n", 59 | "# stuff I installed via conda/pip and local file imports (we don't have those here)\n", 60 | "import os\n", 61 | "import re\n", 62 | "import time\n", 63 | "import enum\n", 64 | "\n", 65 | "\n", 66 | "import cv2 as cv\n", 67 | "import numpy as np\n", 68 | "import matplotlib.pyplot as plt\n", 69 | "import git\n", 70 | "\n", 71 | "\n", 72 | "import torch\n", 73 | "from torch import nn\n", 74 | "from torch.optim import Adam\n", 75 | "from torchvision import transforms, datasets\n", 76 | "from torchvision.utils import make_grid, save_image\n", 77 | "from torch.utils.data import DataLoader\n", 78 | "from torch.utils.tensorboard import SummaryWriter" 79 | ] 80 | }, 81 | { 82 | "cell_type": "code", 83 | "execution_count": 2, 84 | "metadata": {}, 85 | "outputs": [], 86 | "source": [ 87 | "# Let's create some constant to make stuff a bit easier\n", 88 | "BINARIES_PATH = os.path.join(os.getcwd(), 'models', 'binaries') # location where trained models are located\n", 89 | "CHECKPOINTS_PATH = os.path.join(os.getcwd(), 'models', 'checkpoints') # semi-trained models during training will be dumped here\n", 90 | "DATA_DIR_PATH = os.path.join(os.getcwd(), 'data') # all data both input (MNIST) and generated will be stored here\n", 91 | "DEBUG_IMAGERY_PATH = os.path.join(DATA_DIR_PATH, 'debug_imagery') # we'll be dumping images here during GAN training\n", 92 | "\n", 93 | "MNIST_IMG_SIZE = 28 # MNIST images have 28x28 resolution, it's just convinient to put this into a constant you'll see later why" 94 | ] 95 | }, 96 | { 97 | "cell_type": "markdown", 98 | "metadata": {}, 99 | "source": [ 100 | "## Understand your data - Become One With Your Data!\n", 101 | "\n", 102 | "You should always invest time to understand your data. You should be able to answer questions like:\n", 103 | "1. How many images do I have?\n", 104 | "2. What's the shape of my image?\n", 105 | "3. How do my images look like?\n", 106 | "\n", 107 | "So let's first answer those questions!" 108 | ] 109 | }, 110 | { 111 | "cell_type": "code", 112 | "execution_count": 3, 113 | "metadata": {}, 114 | "outputs": [ 115 | { 116 | "name": "stdout", 117 | "output_type": "stream", 118 | "text": [ 119 | "Dataset size: 60000 images.\n", 120 | "Image shape torch.Size([1, 28, 28])\n" 121 | ] 122 | }, 123 | { 124 | "data": { 125 | "image/png": "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\n", 126 | "text/plain": [ 127 | "