kaggle_username

kaggle_key

Gain insights into Generative Adversarial Networks with PyTorch. Delve into neural networks, adversarial training, and building GANs for image generation, including conditional GANs for class-specific data.

GAN.tar.gz

torch

J03T

J03O

J03P

J04AF

J04OF

J04N

J04CR

J05UCP

J07TMG

J07TTMG

J16TG

J16CGR

JAppebdixB

JAppebdixD

SPA04

SPA16

SPA13

SPA09

This course is an introduction to Generative Adversarial Networks (GANs) and a practical step-by-step tutorial on making your own with PyTorch. Through this course, you will learn how to build GANs with industry-standard tools.

In the first section, you will dive into PyTorch and refresh your understanding of neural networks by building a simple image classifier. In the second section of this course, you will explore the idea of adversarial training and build progressively more sophisticated GANs; first by learning a simple 1010 pattern, then monochrome images of handwritten digits, and finally full-color images of faces.

The third, and last section, extends the core GAN concept, applying it to convolutional neural networks, and developing a conditional GAN for generating data of the desired class.

By the end of this course, you will have a solid understanding of how to build GANs for your machine learning projects.

Make Your First GAN Using PyTorch

The code is similar to the code we used for training the MNIST GAN  [here](https://www.educative.io/courses/make-your-first-gan-pytorch/training-the-human-faces-gan).

# Training the Fashion MNIST GAN

We’re ready to train the GAN using the **3** step training loop. Have a look at the following code:

import torch
import torch.nn as nn

# generator class
class Generator(nn.Module):
    
    def __init__(self):
        # initialise parent pytorch class
        super().__init__()
        
        # define neural network layers
        self.model = nn.Sequential(
            nn.Linear(100, 200),
            nn.LeakyReLU(0.02),

            nn.LayerNorm(200),

            nn.Linear(200, 784),
            nn.Sigmoid()
        )
        
        # create optimiser, simple stochastic gradient descent
        self.optimiser = torch.optim.Adam(self.parameters(), lr=0.0001)

        # counter and accumulator for progress
        self.counter = 0;
        self.progress = []
        
        pass
    
    
    def forward(self, inputs):        
        # simply run model
        return self.model(inputs)
    
    
    def train(self, D, inputs, targets):
        # calculate the output of the network
        g_output = self.forward(inputs)
        
        # pass onto Discriminator
        d_output = D.forward(g_output)
        
        # calculate error
        loss = D.loss_function(d_output, targets)

        # increase counter and accumulate error every 10
        self.counter += 1;
        if (self.counter % 10 == 0):
            self.progress.append(loss.item())
            pass

        # zero gradients, perform a backward pass, update weights
        self.optimiser.zero_grad()
        loss.backward()
        self.optimiser.step()

        pass
    
    
    def plot_progress(self):
        df = pandas.DataFrame(self.progress, columns=['loss'])
        df.plot(ylim=(0), figsize=(16,8), alpha=0.1, marker='.', grid=True, yticks=(0, 0.25, 0.5, 1.0, 5.0))
        pass
    
    pass

import torch
import torch.nn as nn

# discriminator class
class Discriminator(nn.Module):
    
    def __init__(self):
        # initialise parent pytorch class
        super().__init__()
        
        # define neural network layers
        self.model = nn.Sequential(
            nn.Linear(784, 200),
            nn.LeakyReLU(0.02),

            nn.LayerNorm(200),

            nn.Linear(200, 1),
            nn.Sigmoid()
        )
        
        # create loss function
        self.loss_function = nn.BCELoss()

        # create optimiser, simple stochastic gradient descent
        self.optimiser = torch.optim.Adam(self.parameters(), lr=0.0001)

        # counter and accumulator for progress
        self.counter = 0;
        self.progress = []

        pass
    
    
    def forward(self, inputs):
        # simply run model
        return self.model(inputs)
    
    
    def train(self, inputs, targets):
        # calculate the output of the network
        outputs = self.forward(inputs)
        
        # calculate loss
        loss = self.loss_function(outputs, targets)

        # increase counter and accumulate error every 10
        self.counter += 1;
        if (self.counter % 10 == 0):
            self.progress.append(loss.item())
            pass
        if (self.counter % 10000 == 0):
            print("counter = ", self.counter)
            pass

        # zero gradients, perform a backward pass, update weights
        self.optimiser.zero_grad()
        loss.backward()
        self.optimiser.step()

        pass
    
    
    def plot_progress(self):
        df = pandas.DataFrame(self.progress, columns=['loss'])
        df.plot(ylim=(0), figsize=(16,8), alpha=0.1, marker='.', grid=True, yticks=(0, 0.25, 0.5, 1.0, 5.0))
        pass
    
    pass

import torch
import torch.nn as nn
from torch.utils.data import Dataset

import pandas, numpy, random
import matplotlib.pyplot as plt

# dataset class

class FMnistDataset(Dataset):
    
    def __init__(self, csv_file):
        self.data_df = pandas.read_csv(csv_file, header=0)
        pass
    
    def __len__(self):
        return len(self.data_df)
    
    def __getitem__(self, index):
        # image target (label)
        label = self.data_df.iloc[index,0]
        target = torch.zeros((10))
        target[label] = 1.0
        
        # image data, normalised from 0-255 to 0-1
        image_values = torch.FloatTensor(self.data_df.iloc[index,1:].values) / 255.0
        
        # return label, image data tensor and target tensor
        return label, image_values, target
    
    def plot_image(self, index):
        img = self.data_df.iloc[index,1:].values.reshape(28,28)
        plt.title("label = " + str(self.data_df.iloc[index,0]))
        plt.imshow(img, interpolation='none', cmap='Blues')
        pass
    
    pass

import torch
import matplotlib.pyplot as plt
from Dataset import FMnistDataset
from Discriminator import Discriminator
from Generator import Generator

# load data
fmnist_dataset = FMnistDataset('fashion-mnist_train.csv')

# functions to generate random data
def generate_random_image(size):
    random_data = torch.rand(size)
    return random_data


def generate_random_seed(size):
    random_data = torch.randn(size)
    return random_data

# create Discriminator and Generator

D = Discriminator()
G = Generator()

epochs = 4

for epoch in range(epochs):
  print ("epoch = ", epoch + 1)
  # train Discriminator and Generator
  for label, image_data_tensor, target_tensor in fmnist_dataset:
    # train discriminator on true
    D.train(image_data_tensor, torch.FloatTensor([1.0]))
    
    # train discriminator on false
    # use detach() so gradients in G are not calculated
    D.train(G.forward(generate_random_seed(100)).detach(), torch.FloatTensor([0.0]))
    
    # train generator
    G.train(D, generate_random_seed(100), torch.FloatTensor([1.0]))

    pass
    
  pass

# plot several outputs from the trained generator
# plot a 3 column, 2 row array of generated images
f, axarr = plt.subplots(2,3, figsize=(16,8))
for i in range(2):
    for j in range(3):
        output = G.forward(generate_random_seed(100))
        img = output.detach().numpy().reshape(28,28)
        axarr[i,j].imshow(img, interpolation='none', cmap='Blues')
        pass
    pass

        # define neural network layers
        self.model = nn.Sequential(
            nn.Linear(100, 200),
            nn.LeakyReLU(0.02),

            nn.LayerNorm(200),

            nn.Linear(200, 784),
            nn.Sigmoid()
        )
        
        # create optimiser, adam
        self.optimiser = torch.optim.Adam(self.parameters(), lr=0.0001)

## Discriminator and generator objects 
We first create fresh discriminator and generator objects, before running the training loop **10,000** times. 

## Training loop

Inside the loop, we can see the **3** steps of the GAN training loop we talked about earlier. 

- For **step 1**, we can see the discriminator being trained on the real data (*line 32*).

- For **step 2**, we train the discriminator with a fake image made of entirely random valued pixels created using `generate_random_seed(100)`. The discriminator is trained to label these as fake with an output of 0.0. Note that `detach()` applied to the output of the generator detaches it from the computation graph (*line 36*).

- For **step 3**, we train the generator, passing it the discriminator object and a **random seed** value generated using `generate_random_seed(100)` (_line 39_).


# Running trained generator output

We can have a look at the actual images the generator makes (*line 47-54*). As we’re expecting different images to be produced by different random seeds, we make a plot of more than one output image.


# Experimenting with seeds
We can experiment with different seed values as discussed [here](https://www.educative.io/courses/make-your-first-gan-pytorch/experimenting-with-seeds). Have a look at how the images look for seeds at regular intervals between `seed1` and `seed2` in the Jupyter Notebook below.
>📝 **How to use a Jupyter NoteBook?**
>
> - Enter the username and key by following the instructions #concept=Kaggle_Jupyter_Notebook#here#concept#.
>
>    Your fashion mnist dataset will be downloaded and will be available in the `fashion_mnist` folder with the notebook files 🎉.
>
> - Click on “**Run**” 🚀 button to work and see the code running live in the notebook.
>
> - You can click <img src="/udata/kklYGo9ovxQ/launch_icon.png" width="30"/> to **open the Jupyter Notebook** in a new tab.
>
> - Go to files and click "Download as" and then choose the format of the file to **download** 📥. You can choose Notebook(.ipynb) to download the file and work locally or on your personal Jupyter Notebook.
>
> - ⚠️ The **notebook session expires after 15 minutes**. It will reset after 15 consecutive minutes.

Learn how we can now train the fashion MNIST pattern GAN.

✨Introduction

✨PyTorch Basics

🖥️ Project: Computation Graph and Gradient Calculation

✨First PyTorch Neural Network

✨Refinements

🖥️ Project: Fashion MNIST Classification Model

✨CUDA Basics

Make Your First GAN: Part 1 - Exam

✨The GAN Idea

✨Simple 1010 Pattern

🖥️ Project: A Simple 01110 Pattern GAN

✨Handwritten Digits

🖥️ Project: Fashion MNIST GAN

✨Human Faces

Make Your First GAN: Part 2 - Exam

✨Convolutional GANs

🖥️ Project: A Fashion MNIST CNN

✨Conditional GANs

🖥️ Project: Fashion MNIST Conditional GAN

Make Your First GAN: Part 3 - Exam

✨Conclusion

✨Appendix

Training The Fashion MNIST GAN