Day 73.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Image Creation with Deep Convolutional GANs(Generative Adversarial Networks)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Part 1: Data Preprocessing"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Importing the libraries\n",
    "from __future__ import print_function\n",
    "import torch\n",
    "import torch.nn as nn\n",
    "import torch.nn.parallel\n",
    "import torch.optim as optim\n",
    "import torch.utils.data\n",
    "import torchvision.datasets as dset\n",
    "import torchvision.transforms as transforms\n",
    "import torchvision.utils as vutils\n",
    "from torch.autograd import Variable"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Setting some hyperparameters\n",
    "batchSize = 64 # set the size of the batch.\n",
    "imageSize = 64 # set the size of the generated images (64x64)."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "C:\\Users\\amira\\Anaconda3\\envs\\face\\lib\\site-packages\\torchvision\\transforms\\transforms.py:188: UserWarning: The use of the transforms.Scale transform is deprecated, please use transforms.Resize instead.\n",
      "  \"please use transforms.Resize instead.\")\n"
     ]
    }
   ],
   "source": [
    "# Creating the transformations\n",
    "transform = transforms.Compose([transforms.Scale(imageSize), transforms.ToTensor(), transforms.Normalize((0.5, 0.5, 0.5), (0.5, 0.5, 0.5)),]) # create a list of transformations (scaling, tensor conversion, normalization) to apply to the input images."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Files already downloaded and verified\n"
     ]
    }
   ],
   "source": [
    "# Loading the dataset\n",
    "dataset = dset.CIFAR10(root = './data', download = True, transform = transform) # download the training set in the ./data folder and i apply the previous transformations on each image.\n",
    "dataloader = torch.utils.data.DataLoader(dataset, batch_size = batchSize, shuffle = True, num_workers = 2) # I use dataLoader to get the images of the training set batch by batch."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Defining the weights_init function that takes as input a neural network m and that will initialize all its weights.\n",
    "def weights_init(m):\n",
    "    classname = m.__class__.__name__\n",
    "    if classname.find('Conv') != -1:\n",
    "        m.weight.data.normal_(0.0, 0.02)\n",
    "    elif classname.find('BatchNorm') != -1:\n",
    "        m.weight.data.normal_(1.0, 0.02)\n",
    "        m.bias.data.fill_(0)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Defining the generator\n",
    "\n",
    "class G(nn.Module): # I introduce a class to define the generator.\n",
    "\n",
    "    def __init__(self): # I introduce the __init__() function that will define the architecture of the generator.\n",
    "        super(G, self).__init__() # I inherit from the nn.Module tools.\n",
    "        self.main = nn.Sequential( # I create a meta module of a neural network that will contain a sequence of modules (convolutions, full connections, etc.).\n",
    "            nn.ConvTranspose2d(100, 512, 4, 1, 0, bias = False), # I start with an inversed convolution.\n",
    "            nn.BatchNorm2d(512), # I normalize all the features along the dimension of the batch.\n",
    "            nn.ReLU(True), # I apply a ReLU rectification to break the linearity.\n",
    "            nn.ConvTranspose2d(512, 256, 4, 2, 1, bias = False), # I add another inversed convolution.\n",
    "            nn.BatchNorm2d(256), # I normalize again.\n",
    "            nn.ReLU(True), # I apply another ReLU.\n",
    "            nn.ConvTranspose2d(256, 128, 4, 2, 1, bias = False), # I add another inversed convolution.\n",
    "            nn.BatchNorm2d(128), # I normalize again.\n",
    "            nn.ReLU(True), # I apply another ReLU.\n",
    "            nn.ConvTranspose2d(128, 64, 4, 2, 1, bias = False), # I add another inversed convolution.\n",
    "            nn.BatchNorm2d(64), # I normalize again.\n",
    "            nn.ReLU(True), # I apply another ReLU.\n",
    "            nn.ConvTranspose2d(64, 3, 4, 2, 1, bias = False), # I add another inversed convolution.\n",
    "            nn.Tanh() # I apply a Tanh rectification to break the linearity and stay between -1 and +1.\n",
    "        )\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [],
   "source": [
    "def forward(self, input): # define the forward function that takes as argument an input that will be fed to the neural network, and that will return the output which will be a value between 0 and 1.\n",
    "        output = self.main(input) # forward propagate the signal through the whole neural network of the discriminator defined by self.main.\n",
    "        return output.view(-1) #  return the output which will be a value between 0 and 1."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Creating the discriminator\n",
    "netD = D() # create the discriminator object.\n",
    "netD.apply(weights_init) # initialize all the weights of its neural network."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Training the DCGANs\n",
    "criterion = nn.BCELoss() #  create a criterion object that will measure the error between the prediction and the target.\n",
    "optimizerD = optim.Adam(netD.parameters(), lr = 0.0002, betas = (0.5, 0.999)) #  create the optimizer object of the discriminator.\n",
    "optimizerG = optim.Adam(netG.parameters(), lr = 0.0002, betas = (0.5, 0.999)) #  create the optimizer object of the generator."
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.5.5"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}