GAN - PYTORCH.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "import numpy as np\n",
    "import torch\n",
    "import torch.nn as nn\n",
    "import torch.nn.functional as F\n",
    "from torch import optim \n",
    "from torchvision import datasets , transforms"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [],
   "source": [
    "def mnist_data():\n",
    "    compose = transforms.Compose(\n",
    "        [transforms.ToTensor(),\n",
    "         transforms.Normalize((.5, .5, .5), (.5, .5, .5))\n",
    "        ])\n",
    "    out_dir = './dataset'\n",
    "    return datasets.MNIST(root=out_dir, train=True, transform=compose, download=True)\n",
    "# Load data\n",
    "data = mnist_data()\n",
    "# Create loader with data, so that we can iterate over it\n",
    "data_loader = torch.utils.data.DataLoader(data, batch_size=100, shuffle=True)\n",
    "# Num batches\n",
    "num_batches = len(data_loader)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [],
   "source": [
    "def image_to_vec(image):\n",
    "    return image.view(image.shape[0] , 784)\n",
    "def vec_to_image(image):\n",
    "    return image.view(image.shape[0] , 1 , 28 , 28)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [],
   "source": [
    "class Discriminator(nn.Module):\n",
    "    def __init__(self):\n",
    "        super().__init__()\n",
    "        self.fc1 = nn.Linear(784 , 128)\n",
    "        self.fc2 = nn.LeakyReLU(0.2)\n",
    "        self.fc3 = nn.Dropout(0.2)\n",
    "        self.fc4 = nn.Linear(128 , 1)\n",
    "        \n",
    "    def forward(self , x):\n",
    "        x = self.fc1(x)\n",
    "        x = self.fc2(x)\n",
    "        x = self.fc3(x)\n",
    "        x = torch.sigmoid(self.fc4(x))\n",
    "        return x"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [],
   "source": [
    "class Generator(nn.Module):\n",
    "    def __init__(self):\n",
    "        super().__init__()\n",
    "        self.fc1 = nn.Linear(100 , 128)\n",
    "        self.fc2 = nn.LeakyReLU(0.2)\n",
    "        self.fc3 = nn.Linear(128 , 64)\n",
    "        self.fc4 = nn.LeakyReLU(0.2)\n",
    "        self.fc5 = nn.Linear(64 , 784)\n",
    "        \n",
    "    def forward(self , x):\n",
    "        x = self.fc1(x)\n",
    "        x = self.fc2(x)\n",
    "        x = self.fc3(x)\n",
    "        x = torch.tanh(self.fc5(self.fc4(x)))\n",
    "        return x"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [],
   "source": [
    "def noise(size):\n",
    "    return torch.randn((size , 100))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [],
   "source": [
    "discriminator , generator = Discriminator() , Generator()\n",
    "d_optimizer = optim.Adam(discriminator.parameters(), lr=0.0002)\n",
    "g_optimizer = optim.Adam(generator.parameters(), lr=0.0002)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [],
   "source": [
    "criterion = nn.BCELoss()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [],
   "source": [
    "def target_vals(size):\n",
    "    return torch.ones(size , 1) , torch.zeros(size , 1)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [],
   "source": [
    "def train_discriminator(optimizer , real_labels , fake_label , real_images , fake_images):\n",
    "    optimizer.zero_grad()\n",
    "    \n",
    "    pred = discriminator(real_images)\n",
    "    loss_disc_real = criterion(pred , real_labels)\n",
    "    loss_disc_real.backward()\n",
    "    \n",
    "    pred_fake = discriminator(fake_images)\n",
    "    loss_disc_fake = criterion(pred_fake , fake_labels)\n",
    "    loss_disc_fake.backward()\n",
    "    \n",
    "    optimizer.step()\n",
    "    return loss_disc_real + loss_disc_fake"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [],
   "source": [
    "def train_generator(optimizer , fake_data , fake_labels):\n",
    "    \n",
    "    optimizer.zero_grad()\n",
    "    loss = criterion(discriminator(generator(fake_data)) , fake_labels)\n",
    "    loss.backward()\n",
    "    optimizer.step()\n",
    "    return loss"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "torch.Size([100, 784])"
      ]
     },
     "execution_count": 12,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "generator(noise(100)).shape"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "epoch  1 generator loss  tensor(0.8508, grad_fn=<BinaryCrossEntropyBackward>) discriminator loss  tensor(0.8628, grad_fn=<AddBackward0>)\n",
      "epoch  2 generator loss  tensor(1.0729, grad_fn=<BinaryCrossEntropyBackward>) discriminator loss  tensor(0.9015, grad_fn=<AddBackward0>)\n",
      "epoch  3 generator loss  tensor(0.9488, grad_fn=<BinaryCrossEntropyBackward>) discriminator loss  tensor(1.0301, grad_fn=<AddBackward0>)\n",
      "epoch  4 generator loss  tensor(1.2277, grad_fn=<BinaryCrossEntropyBackward>) discriminator loss  tensor(0.6899, grad_fn=<AddBackward0>)\n",
      "epoch  5 generator loss  tensor(1.4518, grad_fn=<BinaryCrossEntropyBackward>) discriminator loss  tensor(0.5941, grad_fn=<AddBackward0>)\n",
      "epoch  6 generator loss  tensor(1.4157, grad_fn=<BinaryCrossEntropyBackward>) discriminator loss  tensor(0.7151, grad_fn=<AddBackward0>)\n",
      "epoch  7 generator loss  tensor(1.6604, grad_fn=<BinaryCrossEntropyBackward>) discriminator loss  tensor(0.6775, grad_fn=<AddBackward0>)\n",
      "epoch  8 generator loss  tensor(1.4045, grad_fn=<BinaryCrossEntropyBackward>) discriminator loss  tensor(0.8826, grad_fn=<AddBackward0>)\n",
      "epoch  9 generator loss  tensor(1.4614, grad_fn=<BinaryCrossEntropyBackward>) discriminator loss  tensor(0.7987, grad_fn=<AddBackward0>)\n",
      "epoch  10 generator loss  tensor(1.4466, grad_fn=<BinaryCrossEntropyBackward>) discriminator loss  tensor(0.8187, grad_fn=<AddBackward0>)\n",
      "epoch  11 generator loss  tensor(1.5604, grad_fn=<BinaryCrossEntropyBackward>) discriminator loss  tensor(0.7158, grad_fn=<AddBackward0>)\n",
      "epoch  12 generator loss  tensor(2.1948, grad_fn=<BinaryCrossEntropyBackward>) discriminator loss  tensor(0.5997, grad_fn=<AddBackward0>)\n",
      "epoch  13 generator loss  tensor(2.0047, grad_fn=<BinaryCrossEntropyBackward>) discriminator loss  tensor(0.5407, grad_fn=<AddBackward0>)\n",
      "epoch  14 generator loss  tensor(1.7878, grad_fn=<BinaryCrossEntropyBackward>) discriminator loss  tensor(0.6985, grad_fn=<AddBackward0>)\n",
      "epoch  15 generator loss  tensor(2.0718, grad_fn=<BinaryCrossEntropyBackward>) discriminator loss  tensor(0.5873, grad_fn=<AddBackward0>)\n",
      "epoch  16 generator loss  tensor(2.1541, grad_fn=<BinaryCrossEntropyBackward>) discriminator loss  tensor(0.6567, grad_fn=<AddBackward0>)\n",
      "epoch  17 generator loss  tensor(1.5583, grad_fn=<BinaryCrossEntropyBackward>) discriminator loss  tensor(0.8514, grad_fn=<AddBackward0>)\n",
      "epoch  18 generator loss  tensor(1.8490, grad_fn=<BinaryCrossEntropyBackward>) discriminator loss  tensor(0.8288, grad_fn=<AddBackward0>)\n",
      "epoch  19 generator loss  tensor(1.9963, grad_fn=<BinaryCrossEntropyBackward>) discriminator loss  tensor(0.7338, grad_fn=<AddBackward0>)\n",
      "epoch  20 generator loss  tensor(1.6108, grad_fn=<BinaryCrossEntropyBackward>) discriminator loss  tensor(0.9054, grad_fn=<AddBackward0>)\n",
      "epoch  21 generator loss  tensor(1.7749, grad_fn=<BinaryCrossEntropyBackward>) discriminator loss  tensor(0.8314, grad_fn=<AddBackward0>)\n",
      "epoch  22 generator loss  tensor(2.2104, grad_fn=<BinaryCrossEntropyBackward>) discriminator loss  tensor(0.6428, grad_fn=<AddBackward0>)\n",
      "epoch  23 generator loss  tensor(2.1203, grad_fn=<BinaryCrossEntropyBackward>) discriminator loss  tensor(0.6792, grad_fn=<AddBackward0>)\n",
      "epoch  24 generator loss  tensor(2.2728, grad_fn=<BinaryCrossEntropyBackward>) discriminator loss  tensor(0.7193, grad_fn=<AddBackward0>)\n",
      "epoch  25 generator loss  tensor(2.0642, grad_fn=<BinaryCrossEntropyBackward>) discriminator loss  tensor(0.7387, grad_fn=<AddBackward0>)\n",
      "epoch  26 generator loss  tensor(1.9029, grad_fn=<BinaryCrossEntropyBackward>) discriminator loss  tensor(0.7706, grad_fn=<AddBackward0>)\n",
      "epoch  27 generator loss  tensor(1.7691, grad_fn=<BinaryCrossEntropyBackward>) discriminator loss  tensor(0.8326, grad_fn=<AddBackward0>)\n",
      "epoch  28 generator loss  tensor(2.2436, grad_fn=<BinaryCrossEntropyBackward>) discriminator loss  tensor(0.7174, grad_fn=<AddBackward0>)\n",
      "epoch  29 generator loss  tensor(1.6394, grad_fn=<BinaryCrossEntropyBackward>) discriminator loss  tensor(0.8195, grad_fn=<AddBackward0>)\n",
      "epoch  30 generator loss  tensor(1.6460, grad_fn=<BinaryCrossEntropyBackward>) discriminator loss  tensor(0.7892, grad_fn=<AddBackward0>)\n",
      "epoch  31 generator loss  tensor(2.1321, grad_fn=<BinaryCrossEntropyBackward>) discriminator loss  tensor(0.7654, grad_fn=<AddBackward0>)\n",
      "epoch  32 generator loss  tensor(1.9295, grad_fn=<BinaryCrossEntropyBackward>) discriminator loss  tensor(0.6749, grad_fn=<AddBackward0>)\n",
      "epoch  33 generator loss  tensor(2.0368, grad_fn=<BinaryCrossEntropyBackward>) discriminator loss  tensor(0.7306, grad_fn=<AddBackward0>)\n",
      "epoch  34 generator loss  tensor(1.4045, grad_fn=<BinaryCrossEntropyBackward>) discriminator loss  tensor(1.0081, grad_fn=<AddBackward0>)\n",
      "epoch  35 generator loss  tensor(1.6215, grad_fn=<BinaryCrossEntropyBackward>) discriminator loss  tensor(0.9402, grad_fn=<AddBackward0>)\n",
      "epoch  36 generator loss  tensor(1.8725, grad_fn=<BinaryCrossEntropyBackward>) discriminator loss  tensor(0.8822, grad_fn=<AddBackward0>)\n",
      "epoch  37 generator loss  tensor(1.8227, grad_fn=<BinaryCrossEntropyBackward>) discriminator loss  tensor(0.7796, grad_fn=<AddBackward0>)\n",
      "epoch  38 generator loss  tensor(1.8112, grad_fn=<BinaryCrossEntropyBackward>) discriminator loss  tensor(0.7925, grad_fn=<AddBackward0>)\n",
      "epoch  39 generator loss  tensor(1.6181, grad_fn=<BinaryCrossEntropyBackward>) discriminator loss  tensor(1.0212, grad_fn=<AddBackward0>)\n",
      "epoch  40 generator loss  tensor(1.4362, grad_fn=<BinaryCrossEntropyBackward>) discriminator loss  tensor(0.8982, grad_fn=<AddBackward0>)\n",
      "epoch  41 generator loss  tensor(1.5722, grad_fn=<BinaryCrossEntropyBackward>) discriminator loss  tensor(0.9541, grad_fn=<AddBackward0>)\n",
      "epoch  42 generator loss  tensor(1.5220, grad_fn=<BinaryCrossEntropyBackward>) discriminator loss  tensor(1.0035, grad_fn=<AddBackward0>)\n",
      "epoch  43 generator loss  tensor(1.5573, grad_fn=<BinaryCrossEntropyBackward>) discriminator loss  tensor(1.0228, grad_fn=<AddBackward0>)\n",
      "epoch  44 generator loss  tensor(1.4560, grad_fn=<BinaryCrossEntropyBackward>) discriminator loss  tensor(1.1023, grad_fn=<AddBackward0>)\n",
      "epoch  45 generator loss  tensor(1.3467, grad_fn=<BinaryCrossEntropyBackward>) discriminator loss  tensor(1.0234, grad_fn=<AddBackward0>)\n",
      "epoch  46 generator loss  tensor(1.2941, grad_fn=<BinaryCrossEntropyBackward>) discriminator loss  tensor(1.1492, grad_fn=<AddBackward0>)\n",
      "epoch  47 generator loss  tensor(1.3627, grad_fn=<BinaryCrossEntropyBackward>) discriminator loss  tensor(1.0022, grad_fn=<AddBackward0>)\n",
      "epoch  48 generator loss  tensor(1.5122, grad_fn=<BinaryCrossEntropyBackward>) discriminator loss  tensor(0.9430, grad_fn=<AddBackward0>)\n",
      "epoch  49 generator loss  tensor(1.3110, grad_fn=<BinaryCrossEntropyBackward>) discriminator loss  tensor(0.9976, grad_fn=<AddBackward0>)\n",
      "epoch  50 generator loss  tensor(1.3314, grad_fn=<BinaryCrossEntropyBackward>) discriminator loss  tensor(1.0694, grad_fn=<AddBackward0>)\n",
      "epoch  51 generator loss  tensor(1.6053, grad_fn=<BinaryCrossEntropyBackward>) discriminator loss  tensor(0.9819, grad_fn=<AddBackward0>)\n",
      "epoch  52 generator loss  tensor(1.9143, grad_fn=<BinaryCrossEntropyBackward>) discriminator loss  tensor(0.8064, grad_fn=<AddBackward0>)\n",
      "epoch  53 generator loss  tensor(1.8254, grad_fn=<BinaryCrossEntropyBackward>) discriminator loss  tensor(0.8927, grad_fn=<AddBackward0>)\n",
      "epoch  54 generator loss  tensor(1.6174, grad_fn=<BinaryCrossEntropyBackward>) discriminator loss  tensor(1.0610, grad_fn=<AddBackward0>)\n",
      "epoch  55 generator loss  tensor(1.7056, grad_fn=<BinaryCrossEntropyBackward>) discriminator loss  tensor(0.9120, grad_fn=<AddBackward0>)\n",
      "epoch  56 generator loss  tensor(1.5991, grad_fn=<BinaryCrossEntropyBackward>) discriminator loss  tensor(1.0234, grad_fn=<AddBackward0>)\n",
      "epoch  57 generator loss  tensor(1.6786, grad_fn=<BinaryCrossEntropyBackward>) discriminator loss  tensor(0.9288, grad_fn=<AddBackward0>)\n",
      "epoch  58 generator loss  tensor(1.5040, grad_fn=<BinaryCrossEntropyBackward>) discriminator loss  tensor(1.0696, grad_fn=<AddBackward0>)\n",
      "epoch  59 generator loss  tensor(1.7372, grad_fn=<BinaryCrossEntropyBackward>) discriminator loss  tensor(0.9129, grad_fn=<AddBackward0>)\n",
      "epoch  60 generator loss  tensor(1.1863, grad_fn=<BinaryCrossEntropyBackward>) discriminator loss  tensor(1.0958, grad_fn=<AddBackward0>)\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "epoch  61 generator loss  tensor(1.2735, grad_fn=<BinaryCrossEntropyBackward>) discriminator loss  tensor(1.1414, grad_fn=<AddBackward0>)\n",
      "epoch  62 generator loss  tensor(1.2237, grad_fn=<BinaryCrossEntropyBackward>) discriminator loss  tensor(0.9456, grad_fn=<AddBackward0>)\n",
      "epoch  63 generator loss  tensor(1.3002, grad_fn=<BinaryCrossEntropyBackward>) discriminator loss  tensor(1.0725, grad_fn=<AddBackward0>)\n",
      "epoch  64 generator loss  tensor(1.3041, grad_fn=<BinaryCrossEntropyBackward>) discriminator loss  tensor(1.0089, grad_fn=<AddBackward0>)\n",
      "epoch  65 generator loss  tensor(1.3354, grad_fn=<BinaryCrossEntropyBackward>) discriminator loss  tensor(1.1957, grad_fn=<AddBackward0>)\n",
      "epoch  66 generator loss  tensor(1.2414, grad_fn=<BinaryCrossEntropyBackward>) discriminator loss  tensor(1.0888, grad_fn=<AddBackward0>)\n",
      "epoch  67 generator loss  tensor(1.1959, grad_fn=<BinaryCrossEntropyBackward>) discriminator loss  tensor(1.1185, grad_fn=<AddBackward0>)\n",
      "epoch  68 generator loss  tensor(1.2565, grad_fn=<BinaryCrossEntropyBackward>) discriminator loss  tensor(1.1201, grad_fn=<AddBackward0>)\n",
      "epoch  69 generator loss  tensor(1.3522, grad_fn=<BinaryCrossEntropyBackward>) discriminator loss  tensor(1.0898, grad_fn=<AddBackward0>)\n",
      "epoch  70 generator loss  tensor(1.1580, grad_fn=<BinaryCrossEntropyBackward>) discriminator loss  tensor(1.1951, grad_fn=<AddBackward0>)\n",
      "epoch  71 generator loss  tensor(1.2574, grad_fn=<BinaryCrossEntropyBackward>) discriminator loss  tensor(1.0697, grad_fn=<AddBackward0>)\n",
      "epoch  72 generator loss  tensor(1.1002, grad_fn=<BinaryCrossEntropyBackward>) discriminator loss  tensor(1.1875, grad_fn=<AddBackward0>)\n",
      "epoch  73 generator loss  tensor(1.0330, grad_fn=<BinaryCrossEntropyBackward>) discriminator loss  tensor(1.2451, grad_fn=<AddBackward0>)\n",
      "epoch  74 generator loss  tensor(1.2660, grad_fn=<BinaryCrossEntropyBackward>) discriminator loss  tensor(1.0682, grad_fn=<AddBackward0>)\n",
      "epoch  75 generator loss  tensor(1.5030, grad_fn=<BinaryCrossEntropyBackward>) discriminator loss  tensor(1.0382, grad_fn=<AddBackward0>)\n",
      "epoch  76 generator loss  tensor(1.2340, grad_fn=<BinaryCrossEntropyBackward>) discriminator loss  tensor(1.0834, grad_fn=<AddBackward0>)\n",
      "epoch  77 generator loss  tensor(1.2515, grad_fn=<BinaryCrossEntropyBackward>) discriminator loss  tensor(1.1517, grad_fn=<AddBackward0>)\n",
      "epoch  78 generator loss  tensor(1.5388, grad_fn=<BinaryCrossEntropyBackward>) discriminator loss  tensor(1.0119, grad_fn=<AddBackward0>)\n",
      "epoch  79 generator loss  tensor(1.3787, grad_fn=<BinaryCrossEntropyBackward>) discriminator loss  tensor(1.0246, grad_fn=<AddBackward0>)\n",
      "epoch  80 generator loss  tensor(1.4735, grad_fn=<BinaryCrossEntropyBackward>) discriminator loss  tensor(1.0275, grad_fn=<AddBackward0>)\n",
      "epoch  81 generator loss  tensor(1.2298, grad_fn=<BinaryCrossEntropyBackward>) discriminator loss  tensor(1.1044, grad_fn=<AddBackward0>)\n",
      "epoch  82 generator loss  tensor(1.3573, grad_fn=<BinaryCrossEntropyBackward>) discriminator loss  tensor(0.9561, grad_fn=<AddBackward0>)\n",
      "epoch  83 generator loss  tensor(1.0180, grad_fn=<BinaryCrossEntropyBackward>) discriminator loss  tensor(1.0719, grad_fn=<AddBackward0>)\n",
      "epoch  84 generator loss  tensor(1.3206, grad_fn=<BinaryCrossEntropyBackward>) discriminator loss  tensor(1.1359, grad_fn=<AddBackward0>)\n",
      "epoch  85 generator loss  tensor(1.2969, grad_fn=<BinaryCrossEntropyBackward>) discriminator loss  tensor(0.9710, grad_fn=<AddBackward0>)\n",
      "epoch  86 generator loss  tensor(1.4006, grad_fn=<BinaryCrossEntropyBackward>) discriminator loss  tensor(1.1240, grad_fn=<AddBackward0>)\n",
      "epoch  87 generator loss  tensor(1.3020, grad_fn=<BinaryCrossEntropyBackward>) discriminator loss  tensor(1.1754, grad_fn=<AddBackward0>)\n",
      "epoch  88 generator loss  tensor(1.1790, grad_fn=<BinaryCrossEntropyBackward>) discriminator loss  tensor(0.9916, grad_fn=<AddBackward0>)\n",
      "epoch  89 generator loss  tensor(1.1238, grad_fn=<BinaryCrossEntropyBackward>) discriminator loss  tensor(1.1904, grad_fn=<AddBackward0>)\n",
      "epoch  90 generator loss  tensor(1.2224, grad_fn=<BinaryCrossEntropyBackward>) discriminator loss  tensor(1.1669, grad_fn=<AddBackward0>)\n",
      "epoch  91 generator loss  tensor(1.0655, grad_fn=<BinaryCrossEntropyBackward>) discriminator loss  tensor(1.2158, grad_fn=<AddBackward0>)\n",
      "epoch  92 generator loss  tensor(1.1721, grad_fn=<BinaryCrossEntropyBackward>) discriminator loss  tensor(1.2101, grad_fn=<AddBackward0>)\n",
      "epoch  93 generator loss  tensor(1.2470, grad_fn=<BinaryCrossEntropyBackward>) discriminator loss  tensor(1.1095, grad_fn=<AddBackward0>)\n",
      "epoch  94 generator loss  tensor(1.0119, grad_fn=<BinaryCrossEntropyBackward>) discriminator loss  tensor(1.2177, grad_fn=<AddBackward0>)\n",
      "epoch  95 generator loss  tensor(1.0169, grad_fn=<BinaryCrossEntropyBackward>) discriminator loss  tensor(1.1761, grad_fn=<AddBackward0>)\n",
      "epoch  96 generator loss  tensor(1.1363, grad_fn=<BinaryCrossEntropyBackward>) discriminator loss  tensor(1.2250, grad_fn=<AddBackward0>)\n",
      "epoch  97 generator loss  tensor(1.0940, grad_fn=<BinaryCrossEntropyBackward>) discriminator loss  tensor(1.2789, grad_fn=<AddBackward0>)\n",
      "epoch  98 generator loss  tensor(1.0833, grad_fn=<BinaryCrossEntropyBackward>) discriminator loss  tensor(1.0963, grad_fn=<AddBackward0>)\n",
      "epoch  99 generator loss  tensor(1.1172, grad_fn=<BinaryCrossEntropyBackward>) discriminator loss  tensor(1.3865, grad_fn=<AddBackward0>)\n"
     ]
    }
   ],
   "source": [
    "for epoch in range(1 , 100):\n",
    "    for batch , (images , _) in enumerate(data_loader):\n",
    "        \n",
    "        N = images.shape[0]\n",
    "        train_data = image_to_vec(images)\n",
    "        fake_data = noise(N)\n",
    "        real_labels , fake_labels = target_vals(N)\n",
    "        \n",
    "        d_loss = train_discriminator(d_optimizer , real_labels , fake_labels , train_data , generator(fake_data))\n",
    "        g_loss = train_generator(g_optimizer , fake_data , real_labels)\n",
    "    print('epoch ' , epoch , 'generator loss ' , str(g_loss) , 'discriminator loss ', str(d_loss))\n",
    "        "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [],
   "source": [
    "import matplotlib.pyplot as plt\n",
    "latent_layer = noise(20)\n",
    "images_final = generator(latent_layer)\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [],
   "source": [
    "arr = images_final.detach().numpy()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [],
   "source": [
    "arr = vec_to_image(images_final)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [],
   "source": [
    "final_arr = arr.detach().numpy()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(20, 1, 28, 28)"
      ]
     },
     "execution_count": 18,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "final_arr.shape"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    },
    {
     "data": {
      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAP8AAAD8CAYAAAC4nHJkAAAABHNCSVQICAgIfAhkiAAAAAlwSFlzAAALEgAACxIB0t1+/AAAADl0RVh0U29mdHdhcmUAbWF0cGxvdGxpYiB2ZXJzaW9uIDIuMi4zLCBodHRwOi8vbWF0cGxvdGxpYi5vcmcvIxREBQAAEZBJREFUeJzt3X2QleV5x/HftWcXMCu+LO8CUbMBoqUJ1q0k0TQkjqkaZ9BpdXRiShrN2lYdnbEzOvzR2Np0aBpNHG1MUBmhVZO0xkiiRh3qBG1SdEWiKIqoFJAVTMEA8rp7rv6xh8xG97meZc/rcn8/M87unus8ey4P+9vnnL2f+77N3QUgPU31bgBAfRB+IFGEH0gU4QcSRfiBRBF+IFGEH0gU4QcSRfiBRDXX8sFG2EgfpdZaPiSQlL16T/t9nw3mvmWF38zOlnSrpIKku9x9QXT/UWrVbDuznIcEEFjhywZ93yG/7DezgqR/lXSOpJMlXWJmJw/1+wGorXLe858maZ27v+Hu+yX9QNLcyrQFoNrKCf9kSRv7fb2pdNvvMbNOM+sys64D2lfGwwGopHLCP9AfFT4wP9jdF7p7h7t3tGhkGQ8HoJLKCf8mSVP7fT1F0uby2gFQK+WE/1lJ08zsRDMbIeliSUsr0xaAahvyUJ+795jZVZIeU99Q3yJ3f6linSF5m+Z/OqxP/eYzYd17eirZzmGnrHF+d39E0iMV6gVADXF5L5Aowg8kivADiSL8QKIIP5Aowg8kqqbz+VEllj19u+mII8JDi3v2xN+7jjs6TfmnX4Z19poqD2d+IFGEH0gU4QcSRfiBRBF+IFGEH0gUQ30VUJjeHtZ7175e3QaC4bji7t3VfWwMW5z5gUQRfiBRhB9IFOEHEkX4gUQRfiBRhB9IFOP8FVD1cXzUnLWMCOt+YH9Yf/uaeNnxibfG05VrgTM/kCjCDySK8AOJIvxAogg/kCjCDySK8AOJKmuc38zWS9opqVdSj7t3VKIpNI688e6m1nhpcBUKmSXfs3fIx0qS74/H2n3fvvj7Bz7xTPy9V50a99YI4/h5KnGRz+fc/TcV+D4AaoiX/UCiyg2/S3rczJ4zs85KNASgNsp92X+6u282s/GSnjCzV9x9ef87lH4pdErSKH2ozIcDUCllnfndfXPp41ZJD0o6bYD7LHT3DnfvaNHIch4OQAUNOfxm1mpmow9+LukLklZXqjEA1VXOy/4Jkh60vh1imyXd5+4/r0hXAKpuyOF39zckfaKCvaAOdl8wO6y/NbcnrE98tCWs7xmb/eLy9utuD4+9//8+FdavG78srHdeenVmbefx8VvQlVfH1yC0fCzeD6HYmvMWd9WrmaW8tQIKMz6aWbP1T8eP2w9DfUCiCD+QKMIPJIrwA4ki/ECiCD+QKJbuPsztf+L4sL6g/Y6wPqNlT1ifXbgqrLffUcyszfufr4bHTvn3eBjxb/7Lwvq1q+/PrF3zzMXhsa3jt4X1Hd+bFNZHv7YjrBdzhvMiva+uy6y5D34aM2d+IFGEH0gU4QcSRfiBRBF+IFGEH0gU4QcSxTj/YaAwpi2z9t1p2WPdkjS1Of79//dbzwjr7d/NHseXpMLz2VNX278Uj0k3HXlkXD/m6LB+24V/llmb2B5PuX1v1HFhfdSe3rBefHFtWG8EnPmBRBF+IFGEH0gU4QcSRfiBRBF+IFGEH0gU4/zDQOGkaWH95kcXZ9bGFDw89t1ivDT3m++NCetNXWvCejhv3eL5+PbheKzd9+Uscb19Z2Zt9M9eD48t5mzvbc3xWgNejK8DaASc+YFEEX4gUYQfSBThBxJF+IFEEX4gUYQfSFTuOL+ZLZJ0nqSt7j6zdFubpB9KOkHSekkXufv26rU5vBXGjQvr6zvjcfzLL/l5WI/G8sc0HREeu6MYb0W9+y9Hh3UpXp8+YoVCWPeWuG5vxWvrF3uz1xrYdW68u3zrT58P63nbaNvIeL0Az7mOoBYGc+a/R9LZ77vtBknL3H2apGWlrwEMI7nhd/flkt7/K3aupIOXlS2WdH6F+wJQZUN9zz/B3bslqfRxfOVaAlALVb+238w6JXVK0ih9qNoPB2CQhnrm32JmkySp9HFr1h3dfaG7d7h7R4viP4IAqJ2hhn+ppHmlz+dJeqgy7QColdzwm9n9kn4laYaZbTKzyyQtkHSWmb0m6azS1wCGEXOP53tX0lHW5rPtzJo9XkVFc88t/h1625vLw/q4pnhe+16P18af1Byvbx8589LLwnrL8l+HdWuO/2y09s6TMmvTvvpS/L1HxHPmm9qODevFbdmXnhTfey88tmxN8TUKqtJ8/xW+TDt8W/wDVcIVfkCiCD+QKMIPJIrwA4ki/ECiCD+QqNov3R0NgTTycsfBkGjTkfFlyyv3TgnrF48ubzb02gPZw1btzfGU3pEvbYy/+Yz2sLz58/HS3nOmvZBZe3vKpPDYnvUbwvoVq+JhyO+dfHJmrXBsPEzYu73MGeqN/LNcwpkfSBThBxJF+IFEEX4gUYQfSBThBxJF+IFE1X6cfxiMfw4omNJ7adfL4aHntXaH9V3xjF290xtvoz3v5XmZtZ/OXBIeu2DF0rB+/tJrwvpt5y4K61c//JXM2vRNK8Nj8zy8LV5+e8P12fWembvCYz9yafb23pLkPfG/yXDAmR9IFOEHEkX4gUQRfiBRhB9IFOEHEkX4gUTVfpy/QeVtqbxuUfbc8InN2XPWJemG7s+G9ScfPDWsL7z89rB+/Ucfy6wdm7NF99hC/Pv/jT//flg/4DnXbQTbh+dtc51nwyd3h/UTxryaWfuL/46vMbjrMxeE9cIv4rUElLPcerQ+RK1w5gcSRfiBRBF+IFGEH0gU4QcSRfiBRBF+IFG54/xmtkjSeZK2uvvM0m03SvqapHdKd5vv7o9Uq8la8H37wvqEn4zIrM34zG/DYx996pSwPuM/3g7r/7Dgj8N6YUxbZu2W00+Mv/fNd4X1mSPiee13vzsrrE9fnD0WX/ZId85YuY3O3rr8ni99MTx2y5xRYf24X4TlhhjHzzOYM/89ks4e4PZvu/us0n/DOvhAinLD7+7LJW2rQS8Aaqic9/xXmdkLZrbIzOK9jwA0nKGG/w5J7ZJmSeqWdHPWHc2s08y6zKzrgOL31QBqZ0jhd/ct7t7r7kVJd0o6LbjvQnfvcPeOFsWTZwDUzpDCb2b9t1e9QNLqyrQDoFYGM9R3v6Q5ksaa2SZJX5c0x8xmqW+0Zr2kK6rYI4AqMK/heORR1uaz7cyaPd6hsOb492BTsE/9xnPiPeqP+9Yvh9RTRQT7DUiSNbeE9e0Xx2sNWDH++WntPpBZa34yZ93+Mn82rWNm9rdeuSY+til+3hp13f4Vvkw7fFvcfAlX+AGJIvxAogg/kCjCDySK8AOJIvxAoli6e5B6X16bWTvlrtHhsVtuzhl5yRvSyhmui45v+vjH4mNffTMsH/NvvwrrxWVTw/qU1ncza91nFMJj84bTCn8wI6xv/NxRmbXJq4bnUF4lceYHEkX4gUQRfiBRhB9IFOEHEkX4gUQRfiBRh804f/OUyWG9Z9NbYb1pWrzEde8r6zJrG26Kx5tH+rNhPU9TzvbhG+/Lnm48fezW8Njdn4/Hs5taW8N6SyE+/qbjHs2sjXgzHms/56a/Devjlzwf1o/7l+wtuht/Ye3q48wPJIrwA4ki/ECiCD+QKMIPJIrwA4ki/ECiDptx/rxx/Lw58dE4vhSPtY96PB5v9qZ43rq8GJb3fjZ7CWpJOua+7O//wuzsOe2SNGPSxrDeO/7osP6z6feGdSl7m+zdxf3hkdv/MH5exu7dm/PYiHDmBxJF+IFEEX4gUYQfSBThBxJF+IFEEX4gUbnj/GY2VdISSRMlFSUtdPdbzaxN0g8lnSBpvaSL3H179VotU5nbPUfruHtvb1mPHW0lLUkjHusK6zsv/1Rm7cOPxWPpvROOCetLHvx+WJfi+f6R5/fHP37t/xn3jvIM5szfI+k6dz9J0iclXWlmJ0u6QdIyd58maVnpawDDRG743b3b3VeWPt8paY2kyZLmSlpcuttiSedXq0kAlXdI7/nN7ARJp0haIWmCu3dLfb8gJI2vdHMAqmfQ4TezIyU9IOlad99xCMd1mlmXmXUd0L6h9AigCgYVfjNrUV/w73X3H5du3mJmk0r1SZIGXCnS3Re6e4e7d7QoXogSQO3kht/MTNLdkta4+y39SkslzSt9Pk/SQ5VvD0C1DGZK7+mSvizpRTNbVbptvqQFkn5kZpdJ2iDpwuq02BjC4bxyt9j+dfb235K04e8+HdZPvOO1zFpxR/wObcvlp4b1d+NZtRqfM1s5Mu+BK8P69NXZS29LUs4AK3Lkht/dn5aU9dN7ZmXbAVArXOEHJIrwA4ki/ECiCD+QKMIPJIrwA4kyL3Oq66E4ytp8tqU3Otg0alRYL+YtQZ13nUDwb2g523t/45WnwvpfvXRpWG87YndY/+2+7P/3o7/4enhsudOwU7TCl2mHb8v5genDmR9IFOEHEkX4gUQRfiBRhB9IFOEHEkX4gUTVfovuaMz6MB3XreY4viQVxo3LrL3519PCY1/bH68lsPTji8L6P78zJ6w/94/BegEeb4uO6uLMDySK8AOJIvxAogg/kCjCDySK8AOJIvxAopjPf5jLW0ugaUxbWPedu+L6/ngb7aZjjs6s9by9JTwWh475/AByEX4gUYQfSBThBxJF+IFEEX4gUYQfSFTufH4zmyppiaSJkoqSFrr7rWZ2o6SvSXqndNf57v5ItRrF0OStJVDsjsfarSkeMt77p6eE9ZEPPxvWUT+DWcyjR9J17r7SzEZLes7MnijVvu3u36peewCqJTf87t4tqbv0+U4zWyNpcrUbA1Bdh/Se38xOkHSKpBWlm64ysxfMbJGZHZtxTKeZdZlZ1wHtK6tZAJUz6PCb2ZGSHpB0rbvvkHSHpHZJs9T3yuDmgY5z94Xu3uHuHS2K940DUDuDCr+Ztagv+Pe6+48lyd23uHuvuxcl3SnptOq1CaDScsNvZibpbklr3P2WfrdP6ne3CyStrnx7AKplMH/tP13SlyW9aGarSrfNl3SJmc2S5JLWS7qiKh2iuoq9YdmL8eEM5Q1fg/lr/9OSBhrsZUwfGMa4wg9IFOEHEkX4gUQRfiBRhB9IFOEHElX7LbrRWMrcHnzYPjY48wOpIvxAogg/kCjCDySK8AOJIvxAogg/kKiabtFtZu9I+t9+N42V9JuaNXBoGrW3Ru1LorehqmRvx7v7uMHcsabh/8CDm3W5e0fdGgg0am+N2pdEb0NVr9542Q8kivADiap3+BfW+fEjjdpbo/Yl0dtQ1aW3ur7nB1A/9T7zA6iTuoTfzM42s1fNbJ2Z3VCPHrKY2Xoze9HMVplZV517WWRmW81sdb/b2szsCTN7rfRxwG3S6tTbjWb2Vum5W2Vm59apt6lm9qSZrTGzl8zsmtLtdX3ugr7q8rzV/GW/mRUkrZV0lqRNkp6VdIm7v1zTRjKY2XpJHe5e9zFhM/sTSbskLXH3maXbvilpm7svKP3iPNbdr2+Q3m6UtKveOzeXNpSZ1H9naUnnS/qK6vjcBX1dpDo8b/U4858maZ27v+Hu+yX9QNLcOvTR8Nx9uaRt77t5rqTFpc8Xq++Hp+YyemsI7t7t7itLn++UdHBn6bo+d0FfdVGP8E+WtLHf15vUWFt+u6THzew5M+usdzMDmFDaNv3g9unj69zP++Xu3FxL79tZumGeu6HseF1p9Qj/QGs3NdKQw+nu/keSzpF0ZenlLQZnUDs318oAO0s3hKHueF1p9Qj/JklT+309RdLmOvQxIHffXPq4VdKDarzdh7cc3CS19HFrnfv5nUbauXmgnaXVAM9dI+14XY/wPytpmpmdaGYjJF0saWkd+vgAM2st/SFGZtYq6QtqvN2Hl0qaV/p8nqSH6tjL72mUnZuzdpZWnZ+7Rtvxui4X+ZSGMr4jqSBpkbt/o+ZNDMDMPqK+s73Ut7LxffXszczulzRHfbO+tkj6uqSfSPqRpA9L2iDpQnev+R/eMnqbo76Xrr/bufnge+wa93aGpKckvSjp4D7D89X3/rpuz13Q1yWqw/PGFX5AorjCD0gU4QcSRfiBRBF+IFGEH0gU4QcSRfiBRBF+IFH/D9IPEyyLfN1LAAAAAElFTkSuQmCC\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "for array in final_arr: \n",
    "    plt.imshow(array.reshape(28,28))\n",
    "    plt.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    },
    {
     "data": {
      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAP8AAAD8CAYAAAC4nHJkAAAABHNCSVQICAgIfAhkiAAAAAlwSFlzAAALEgAACxIB0t1+/AAAADl0RVh0U29mdHdhcmUAbWF0cGxvdGxpYiB2ZXJzaW9uIDIuMi4zLCBodHRwOi8vbWF0cGxvdGxpYi5vcmcvIxREBQAAEPhJREFUeJzt3X+MVeWdx/HPl+GXIr8Vikj9gbruikENMWqrYbOhsaQRGlN/xCDGtfSPEqlpdI0x1hhN6mbbWiKpGVMimtZqgi4m1rVoNLrJxvCrFq3bagwUEGZURBH5zXf/mGt3xDnfZ7jn3nvuzPN+JWTu3O899zxzuJ85d+5znucxdxeA/AypugEAqkH4gUwRfiBThB/IFOEHMkX4gUwRfiBThB/IFOEHMjW0lTszMy4nBJrM3a0/jyt15jezK8zsL2b2rpndUea50BxDhgwJ/yFfVu+1/WbWIemvkuZI2ippjaTr3P3PwTac+VssFfAjR460qCVolVac+S+S9K67v+fuByT9TtK8Es8HoIXKhH+qpC29vt9au+9LzGyRma01s7Ul9gWgwcp84NfXW4uvvK13905JnRJv+4F2UubMv1XStF7fnyLp/XLNAdAqZcK/RtJZZna6mQ2XdK2kZxvTLADNVvfbfnc/ZGaLJb0gqUPScnd/q2EtQ0MM5E/zzeIPrZmFqpy6u/rq2hl/8+MYEP76tOQiHwADF+EHMkX4gUwRfiBThB/IFOEHMtXS8fxojtmzZxfWXnnllXDbp556KqwPHRq/RC688MKwfu211xbW3njjjXDb1DUK+/fvD+uIceYHMkX4gUwRfiBThB/IFOEHMkX4gUwxqq8NdHR0lKqvWbOmsHb33XeH23Z2dob1k046Kaxv3rw5rJ9++ulhPZIa1Zc6LocOHap73wMZo/oAhAg/kCnCD2SK8AOZIvxApgg/kCnCD2SKfv42MGLEiLCeGrp64MCBuved6itfsmRJWH/44YfDepm+9rKLjEbXCTT7dV/lAqn08wMIEX4gU4QfyBThBzJF+IFMEX4gU4QfyFSpqbvNbJOk3ZIOSzrk7rMa0aiBpuxqsuPHjw/rEyZMqHv7VH/ysmXLwvrBgwfD+vz588P6ypUrC2tlx+O38yq+ZfrxJ0+eHNa7urrqfu7eGjFv/z+7+4cNeB4ALcTbfiBTZcPvkv5gZuvMbFEjGgSgNcq+7f+Gu79vZpMkrTaz/3X3V3s/oPZLgV8MQJspdeZ39/drX7slPSPpoj4e0+nus3L9MBBoV3WH38xGmdnoL25L+pakNxvVMADNVeZt/2RJz9S6W4ZK+q27/1dDWgWg6RjPPwBMnDgxrN94442FtQcffDDcduzYsWH9448/DuupuQj27dtXWBs5cmS4beoag7lz54b15557rrDWzPH0VWM8P4AQ4QcyRfiBTBF+IFOEH8gU4Qcy1YhRfUg4/vjjw/q2bdvCempq7qi7bdeuXeG2y5cvD+vDhg0L66lhtxdffHFhbenSpeG2d911V1iPuvKQxpkfyBThBzJF+IFMEX4gU4QfyBThBzJF+IFMtbyfv8plk5tl3LhxYf3yyy8P66mfe9KkSWF9y5YthbX7778/3HbGjBlh/cknnwzrt99+e1g/77zzCmsPPPBAuG3quA4dGr98yyxdngPO/ECmCD+QKcIPZIrwA5ki/ECmCD+QKcIPZKrl/fxRn3Y7L7kcSS2pfPLJJ4f1MWPGhPXUzz1t2rTC2o4dO8Jtb7755rDe3d0d1tesWRPWFyxYUFibOXNmuO3ixYvDesqqVasKa/v37y/13IMBZ34gU4QfyBThBzJF+IFMEX4gU4QfyBThBzKVXKLbzJZL+o6kbnefUbtvgqQnJZ0maZOkq909XstZA3uJ7tGjRxfW9uzZE27b1dUV1lP/B+PHjw/r0dz8w4cPD7edMGFCWE9JLXUd/Wyp5b1Ty4OnfrabbrqpsLZ69epw2+3bt4f1dtbIJboflXTFUffdIekldz9L0ku17wEMIMnwu/urknYedfc8SStqt1dImt/gdgFosnr/5p/s7tslqfY1nmcKQNtp+rX9ZrZI0qJm7wfAsan3zN9lZlMkqfa1cPSHu3e6+yx3n1XnvgA0Qb3hf1bSwtrthZKKh08BaEvJ8JvZE5L+R9I/mNlWM/tXST+VNMfM3pE0p/Y9gAEk2c/f0J21cT9/ai6BqD/8vvvuC7e95JJLwno0t72Uvg6go6OjsPbaa6+F26bWFGimU089Naxv2rSp1PNHxy11fUN07US7a2Q/P4BBiPADmSL8QKYIP5Apwg9kivADmWr51N1VGTIk/j2XGpr60UcfFdaWLFkSbpsaPpry1ltvhfUNGzYU1h555JFS+y5r+vTphbWNGzc2dd87dx49Hu3/HT58ONy27OtlIODMD2SK8AOZIvxApgg/kCnCD2SK8AOZIvxAprLp5y/bLxv1+6ae+6GHHgrr5557blg/++yzw/pll11WWNu7d2+4bbMdd9xxhbXo+gRJuvTSS0vte+LEiYW1ZcuWhdvecMMNpfY9EHDmBzJF+IFMEX4gU4QfyBThBzJF+IFMEX4gU9n085cV9eWfc8454bYvv/xyWE9NI52aunvfvn2FtRNPPDHcdseOHWE9ZdiwYWH9mmuuKaxNnTo13DY15v7QoUNhPZqW/NZbbw23LSs1FXwrp8wvwpkfyBThBzJF+IFMEX4gU4QfyBThBzJF+IFMJZfoNrPlkr4jqdvdZ9Tuu0fS9yV9UHvYne7+++TO2niJ7pQRI0YU1ubOnRtu+/TTTze6OV8SjZlPrSlw4MCBsL5+/fqwvnnz5rB+5plnFtZS6xmk+vHXrVsX1qdMmVJYSy0PPmrUqLC+Z8+esD50aHwJTXTdSNm5Jxq5RPejkq7o4/5fuPv5tX/J4ANoL8nwu/urkoqXPgEwIJX5m3+xmf3JzJab2fiGtQhAS9Qb/l9Jmi7pfEnbJf2s6IFmtsjM1prZ2jr3BaAJ6gq/u3e5+2F3PyLpEUkXBY/tdPdZ7j6r3kYCaLy6wm9mvT9G/a6kNxvTHACtkhzSa2ZPSJot6UQz2yrpJ5Jmm9n5klzSJkk/aGIbATRBMvzufl0fd/+6CW0pNQa62eOno770F154odRzl/XZZ58V1lLHJbUO/apVq8L6li1bwvoZZ5xRWEv9n3R0dIT1rq6usB7NzZ+a5+DDDz8M6ympaxRuueWWwtrSpUtL7bu/uMIPyBThBzJF+IFMEX4gU4QfyBThBzKVHNLb0J0N4CG9kRNOOCGsf/rpp2E91R2Xkpriusy+Dx48GNajacOluCsw1ZV3yimnhPXRo0eH9f379xfWrrzyynDbF198Maynht2mXhNR92xZjRzSC2AQIvxApgg/kCnCD2SK8AOZIvxApgg/kKlBs0R3lUsip/psr7rqqrC+cuXKsJ762aL+8tTPnZqCevfu3WH93nvvDevPP/98YS01FDrVj58SDZvdsGFDuG3qGoRUP3/q+od2wJkfyBThBzJF+IFMEX4gU4QfyBThBzJF+IFMMZ6/BVL91alpoocPH173vlPj8YcNGxbWP/nkk7r3LUmzZhUv1JSa3vqdd94pte9oCfB58+aF26aOWztjPD+AEOEHMkX4gUwRfiBThB/IFOEHMkX4gUwlx/Ob2TRJj0n6mqQjkjrd/ZdmNkHSk5JOk7RJ0tXu/nHzmjpwlR3bvXfv3rA+YsSIwlpq3HnqOo+xY8eG9c8//zysd3d3F9aiefWl8nMwRPMslFnroD+qnF+iv/pz5j8k6cfu/o+SLpb0QzP7J0l3SHrJ3c+S9FLtewADRDL87r7d3dfXbu+W9LakqZLmSVpRe9gKSfOb1UgAjXdMf/Ob2WmSLpD0uqTJ7r5d6vkFIWlSoxsHoHn6PYefmZ0gaaWkH7n7p/1dX87MFklaVF/zADRLv878ZjZMPcH/jbs/Xbu7y8ym1OpTJPX5yY67d7r7LHcvHuEBoOWS4beeU/yvJb3t7j/vVXpW0sLa7YWSVjW+eQCaJTmk18y+Kek1SRvV09UnSXeq5+/+pyR9XdLfJH3P3Xcmnqv6/o02NHLkyLCe6k6Lht2OGzcu3Db1/5/qEkt1Y44ZM6awNnny5HDb1JDe8ePHh/UhQ4rPbQcOHAi3bbboz+ay3YD9HdKb/Jvf3f9bUtGT/cuxNApA++AKPyBThB/IFOEHMkX4gUwRfiBThB/I1KBZonsgS/WV33bbbWH9+uuvL6zNnDkz3DZ1mfa2bdvC+vTp08N61Gedun7hggsuCOupaxCiqcGHDo1f+qlpxcsaKEN6AQxChB/IFOEHMkX4gUwRfiBThB/IFOEHMsUS3QNANC5dkt57773C2uOPPx5u29XVFdbnz4/nZZ0zZ05YL/P6Si1NnhqT38wx86mlzatc4pslugGECD+QKcIPZIrwA5ki/ECmCD+QKcIPZIp+/kEgmr9+165dTd13M18/HR0dYb3s8uODFf38AEKEH8gU4QcyRfiBTBF+IFOEH8gU4QcylZy338ymSXpM0tckHZHU6e6/NLN7JH1f0ge1h97p7r9vVkMHs9Tc+an+7mjM/aOPPlpPk/6uyr7y1Lz8ZaSOeUrquKSevx2uQejPoh2HJP3Y3deb2WhJ68xsda32C3f/j+Y1D0CzJMPv7tslba/d3m1mb0ua2uyGAWiuY/qb38xOk3SBpNdrdy02sz+Z2XIz6/MaUzNbZGZrzWxtqZYCaKh+h9/MTpC0UtKP3P1TSb+SNF3S+ep5Z/CzvrZz9053n+XusxrQXgAN0q/wm9kw9QT/N+7+tCS5e5e7H3b3I5IekXRR85oJoNGS4beejy1/Leltd/95r/un9HrYdyW92fjmAWiW5JBeM/umpNckbVRPV58k3SnpOvW85XdJmyT9oPbhYPRcTevfGAhdK/VKTd2dGto6WHFc+tbfIb2DZjw/4c8Px6VvjOcHECL8QKYIP5Apwg9kivADmSL8QKYGTVdfO0stk71gwYKm7TvVBZpaBju11HSu3WntjK4+ACHCD2SK8AOZIvxApgg/kCnCD2SK8AOZanU//weSNve660RJH7asAcemXdvWru2SaFu9Gtm2U939pP48sKXh/8rOzda269x+7dq2dm2XRNvqVVXbeNsPZIrwA5mqOvydFe8/0q5ta9d2SbStXpW0rdK/+QFUp+ozP4CKVBJ+M7vCzP5iZu+a2R1VtKGImW0ys41m9seqlxirLYPWbWZv9rpvgpmtNrN3al/7XCatorbdY2bbasfuj2Y2t6K2TTOzl83sbTN7y8yW1O6v9NgF7arkuLX8bb+ZdUj6q6Q5krZKWiPpOnf/c0sbUsDMNkma5e6V9wmb2eWSPpP0mLvPqN3375J2uvtPa784x7v7v7VJ2+6R9FnVKzfXFpSZ0ntlaUnzJd2oCo9d0K6rVcFxq+LMf5Gkd939PXc/IOl3kuZV0I625+6vStp51N3zJK2o3V6hnhdPyxW0rS24+3Z3X1+7vVvSFytLV3rsgnZVoorwT5W0pdf3W9VeS367pD+Y2TozW1R1Y/ow+YuVkWpfJ1XcnqMlV25upaNWlm6bY1fPiteNVkX4+5piqJ26HL7h7hdK+rakH9be3qJ/+rVyc6v0sbJ0W6h3xetGqyL8WyVN6/X9KZLer6AdfXL392tfuyU9o/Zbfbjri0VSa1+7K27P37XTys19rSytNjh27bTidRXhXyPpLDM73cyGS7pW0rMVtOMrzGxU7YMYmdkoSd9S+60+/KykhbXbCyWtqrAtX9IuKzcXrSytio9du614XclFPrWujAcldUha7u73t7wRfTCzM9RztpekoZJ+W2XbzOwJSbPVM+qrS9JPJP2npKckfV3S3yR9z91b/sFbQdtm6xhXbm5S24pWln5dFR67Rq543ZD2cIUfkCeu8AMyRfiBTBF+IFOEH8gU4QcyRfiBTBF+IFOEH8jU/wEkprd0muqkzgAAAABJRU5ErkJggg==\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "for array in final_arr: \n",
    "    plt.imshow(array.reshape(28,28) , cmap = 'gray')\n",
    "    plt.show()"
   ]
  }
 ],
 "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.7.1"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}