Added old updated files from seperate account

Author: ddehueck

README.md

@@ -1,2 +1,34 @@
 # pytorch-GAN
-PyTorch implementation of the original GAN paper by Goodfellow et al.
+A PyTorch Implementation of Goodfellow et al.'s Paper on Generative Adversarial Networks. Find the paper at: https://arxiv.org/pdf/1406.2661.pdf
+
+## How to run:
+Currently has MNIST experiment implemented. Built with torch 1.1.0 and python3.6.
+
+`pip install -r requirements.txt`
+
+`python train.py --epochs 300 --lr 1e-4 --batch-size 32`
+
+Once train.py is running one can open a new shell and running tensboard in order to track various metrics and current generated images during training.
+
+`tensorboard --logdir=runs/<CURRENT_RUN_DIRECTORY>`
+
+### How to adjust hyperparameters: 
+**One can use different arguments defined in train.py to adjust various hyperparameters**
+
+```
+--epochs EPOCHS       number of epochs to train for (default: 300)
+  --lr LR               learning rate for optimizer (default: 1e-4)
+  --batch-size BATCH_SIZE
+                        number of examples in a batch (default: 32)
+  --device DEVICE       device to train on (default: cuda:0 if cuda is
+                        available otherwise cpu)
+  --latent-size LATENT_SIZE
+                        size of latent space vectors (default: 64)
+  --g-hidden-size G_HIDDEN_SIZE
+                        number of hidden units per layer in G (default: 256)
+  --d-hidden-size D_HIDDEN_SIZE
+                        number of hidden units per layer in D (default: 256)
+```
+
+## Results:
+![Epoch 2](https://i.imgur.com/MbMaKga.png) ![Epoch 20](https://i.imgur.com/W2po4XH.png) ![Epoch 499](https://i.imgur.com/MBs5P0q.png) ![Epoch 999](https://i.imgur.com/gJ2XoPk.png)

criteria/discriminator.py

@@ -0,0 +1,58 @@
+import torch as t
+from torchvision import datasets, transforms
+from torch.utils.data import DataLoader
+
+
+class GANData:
+
+    def __init__(self, args, root='./data',):
+        self.args = args
+        self.mnist_dataset = MNISTGANDataset(root=root)
+        self.real_loader = DataLoader(
+            self.mnist_dataset,
+            batch_size=args.batch_size,
+            shuffle=True
+        )
+
+    def sample_latent_space(self, batch_size=None):
+        """
+        Sample a normal distribution for latent space vectors
+        (usually denoted by z)
+        :return: a BATCH SIZE x LATENT SIZE tensor
+        """
+        batch_size = self.args.batch_size if batch_size is None else batch_size
+        return t.randn(batch_size, self.args.latent_size)
+
+    def get_fake_labels(self):
+        """
+        :return: a vector of zeros of length batch size
+        """
+        return t.zeros(self.args.batch_size, 1)
+
+
+class MNISTGANDataset(datasets.MNIST):
+
+    def __init__(self, root):
+        super(MNISTGANDataset, self).__init__(
+            root=root,
+            train=True,
+            download=True,
+            transform=transforms.Compose([
+                transforms.ToTensor(),
+                transforms.Normalize((0.5,), (0.5,))
+           ])
+        )
+
+    def __getitem__(self, index):
+        """
+        Args:
+            index (int): Index
+
+        Returns:
+            tuple: (image, target) where target indicates that this
+            is a real image: 1
+        """
+
+        # Replace target with ones
+        img, target = super().__getitem__(index)
+        return img, t.ones(1)

criteria/generator.py

@@ -1,6 +1,4 @@
-import torch as t
 import torch.nn as nn
-import torch.nn.functional as F
 
 
 class Discriminator(nn.Module):
@@ -11,14 +9,21 @@ class Discriminator(nn.Module):
     the input belongs to a the real data distribution.
     """
 
-    def __init__(self, img_size):
+    def __init__(self, img_size, hidden_size):
         super(Discriminator, self).__init__()
 
         self.img_size = img_size
-        self.l1 = nn.Linear(img_size, 64)
-        self.l2 = nn.Linear(64, 128)
-        self.l3 = nn.Linear(128, 64)
-        self.l4 = nn.Linear(64, 1)
+
+        self.model = nn.Sequential(
+            nn.Linear(img_size, hidden_size),
+            nn.LeakyReLU(),
+            nn.Dropout(),
+            nn.Linear(hidden_size, hidden_size),
+            nn.LeakyReLU(),
+            nn.Dropout(),
+            nn.Linear(hidden_size, 1),
+            nn.Sigmoid()
+        )
 
     def forward(self, x):
         """
@@ -27,14 +32,6 @@ def forward(self, x):
         :param x: Image tensor
         :return: Float in range [0, 1] - probability score
         """
-
-        # Resize x into a vector
+        # Resize x from a H x W img to a vector
         x = x.view(-1, self.img_size)
-
-        # Pass through layers with a non-linearity
-        x = F.relu(self.l1(x))
-        x = F.relu(self.l2(x))
-        x = F.relu(self.l3(x))
-
-        # Use sigmoid to convert to a probability
-        return t.sigmoid(self.l4(x))
+        return self.model(x).clamp(1e-9)

data.py

@@ -0,0 +1,37 @@
+import torch.nn as nn
+
+
+class Generator(nn.Module):
+    """
+    Generative Adversarial Network Generator Class
+
+    Takes in a latent vector z and returns a vector in
+    the same image space that the discriminator is trained on.
+
+    """
+
+    def __init__(self, img_size, latent_size, hidden_size):
+        super(Generator, self).__init__()
+
+        self.latent_size = latent_size
+
+        self.model = nn.Sequential(
+            nn.Linear(latent_size, hidden_size),
+            nn.ReLU(),
+            nn.Dropout(),
+            nn.Linear(hidden_size, hidden_size),
+            nn.ReLU(),
+            nn.Dropout(),
+            nn.Linear(hidden_size, img_size),
+            nn.Tanh()
+        )
+
+    def forward(self, z):
+        """
+        Forward pass of a generator
+
+        :param z: Latent space vector - size: batch_size x latent_size
+        :return: Tensor of self.img_size
+        """
+        return self.model(z)
+

generator.py

@@ -0,0 +1,14 @@
+absl-py==0.7.1
+certifi==2019.6.16
+future==0.17.1
+grpcio==1.22.0
+Markdown==3.1.1
+numpy==1.16.4
+Pillow==6.1.0
+protobuf==3.9.0
+six==1.12.0
+tb-nightly==1.15.0a20190720
+torch==1.1.0
+torchvision==0.3.0
+tqdm==4.32.2
+Werkzeug==0.15.5