models/GANs/notebooks/GAN.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Generative Adversarial Network (GAN)\n",
    "```\n",
    "GAN consists of two neural networks: a generator and a discriminator. A normal GAN, however, does not allow class-conditional generation of data. \n",
    "Will will do use conditional GAN for that purpose.\n",
    "```"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [],
   "source": [
    "# necessary imports\n",
    "# add ../src to sys.path\n",
    "import sys\n",
    "sys.path.append('../src')\n",
    "\n",
    "import torch\n",
    "import torch.nn as nn\n",
    "import torch.nn.functional as F\n",
    "import torch.optim as optim\n",
    "import torchvision\n",
    "import torchvision.transforms as transforms\n",
    "\n",
    "import matplotlib.pyplot as plt\n",
    "import numpy as np\n",
    "\n",
    "from tqdm import tqdm, trange\n",
    "\n",
    "import GAN"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [],
   "source": [
    "# load MNIST data\n",
    "transform = transforms.Compose([transforms.ToTensor(), transforms.Normalize((0.5,), (0.5,))])\n",
    "\n",
    "# datasets\n",
    "trainset = torchvision.datasets.MNIST(root='../../data', train=True, download=True, transform=transform)\n",
    "testset = torchvision.datasets.MNIST(root='../../data', train=False, download=True, transform=transform)\n",
    "\n",
    "\n",
    "# data loaders\n",
    "batch_size = 128\n",
    "trainloader = torch.utils.data.DataLoader(trainset, batch_size=batch_size, shuffle=True)\n",
    "testloader = torch.utils.data.DataLoader(testset, batch_size=batch_size, shuffle=False)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 500x500 with 4 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "# visualize some data\n",
    "def visualize_data(data, labels):\n",
    "    fig, axs = plt.subplots(2,2, figsize=(5,5))\n",
    "    axs = axs.flatten()\n",
    "    for i in range(4):\n",
    "        axs[i].imshow(data[i].squeeze(), cmap='gray')\n",
    "        axs[i].set_title(labels[i].item())\n",
    "        axs[i].axis('off')\n",
    "    plt.tight_layout()\n",
    "    plt.show()\n",
    "\n",
    "# visualize some data\n",
    "imgs, labels = next(iter(trainloader))\n",
    "visualize_data(imgs, labels)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "max:  tensor(1.)\n",
      "min:  tensor(-1.)\n"
     ]
    }
   ],
   "source": [
    "# max and min values of the data\n",
    "print('max: ', torch.max(imgs))\n",
    "print('min: ', torch.min(imgs))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "cuda:0\n"
     ]
    }
   ],
   "source": [
    "# device\n",
    "device = torch.device(\"cuda:0\" if torch.cuda.is_available() else \"cpu\")\n",
    "print(device)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [],
   "source": [
    "# image size\n",
    "img_size = imgs[0].shape[1]**2 # 28*28 = 784\n",
    "\n",
    "# noise dim\n",
    "noise_dim = 100"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [],
   "source": [
    "# create generator and discriminator models\n",
    "generator = GAN.Generator(noise_dim, img_size).to(device)\n",
    "discriminator = GAN.Discriminator(img_size).to(device)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "torch.Size([32, 784])\n",
      "torch.Size([32, 1])\n"
     ]
    }
   ],
   "source": [
    "# test generator\n",
    "noise = torch.randn(32, noise_dim).to(device)\n",
    "fake_imgs = generator(noise)\n",
    "print(fake_imgs.shape)\n",
    "\n",
    "# test discriminator\n",
    "preds = discriminator(fake_imgs)\n",
    "print(preds.shape)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [],
   "source": [
    "# optimizers\n",
    "lr = 0.0002\n",
    "beta1 = 0.5\n",
    "beta2 = 0.999\n",
    "optimizer_G = optim.Adam(generator.parameters(), lr=lr, betas=(beta1, beta2))\n",
    "optimizer_D = optim.Adam(discriminator.parameters(), lr=lr, betas=(beta1, beta2))\n",
    "\n",
    "# loss function\n",
    "criterion = nn.BCELoss()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "  0%|          | 1/500 [00:06<56:24,  6.78s/it]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "epoch:  0 loss_D:  1.1428446769714355 loss_G:  0.979158878326416\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      " 10%|█         | 51/500 [05:44<51:22,  6.86s/it]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "epoch:  50 loss_D:  1.1726210117340088 loss_G:  1.2037057876586914\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      " 20%|██        | 101/500 [11:20<45:14,  6.80s/it]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "epoch:  100 loss_D:  1.0457937717437744 loss_G:  1.2390246391296387\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      " 30%|███       | 151/500 [17:02<39:18,  6.76s/it]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "epoch:  150 loss_D:  0.9058335423469543 loss_G:  1.5066449642181396\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      " 40%|████      | 201/500 [22:33<32:27,  6.51s/it]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "epoch:  200 loss_D:  1.0851385593414307 loss_G:  0.9047867059707642\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      " 50%|█████     | 251/500 [28:10<27:54,  6.72s/it]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "epoch:  250 loss_D:  1.003739833831787 loss_G:  1.4300706386566162\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      " 60%|██████    | 301/500 [33:48<22:25,  6.76s/it]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "epoch:  300 loss_D:  0.9848849773406982 loss_G:  1.2346057891845703\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      " 70%|███████   | 351/500 [39:23<16:42,  6.73s/it]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "epoch:  350 loss_D:  0.8986469507217407 loss_G:  1.3470230102539062\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      " 80%|████████  | 401/500 [44:59<10:58,  6.65s/it]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "epoch:  400 loss_D:  0.7752115726470947 loss_G:  1.5048189163208008\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      " 90%|█████████ | 451/500 [50:35<05:32,  6.78s/it]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "epoch:  450 loss_D:  0.8868981599807739 loss_G:  2.0320889949798584\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "100%|██████████| 500/500 [56:02<00:00,  6.73s/it]\n"
     ]
    }
   ],
   "source": [
    "# training loop\n",
    "epochs = 500\n",
    "for epoch in trange(epochs):\n",
    "    for i, (imgs, _) in enumerate(trainloader):\n",
    "        \n",
    "        # real images\n",
    "        real_imgs = imgs.view(-1, img_size).to(device)\n",
    "        batch_size = real_imgs.shape[0]\n",
    "        real_labels = torch.ones(batch_size, 1).to(device)\n",
    "\n",
    "        # fake images\n",
    "        noise = torch.randn(batch_size, noise_dim).to(device)\n",
    "        fake_imgs = generator(noise)\n",
    "        fake_labels = torch.zeros(batch_size, 1).to(device)\n",
    "\n",
    "        # train discriminator\n",
    "        optimizer_D.zero_grad()\n",
    "        real_preds = discriminator(real_imgs)\n",
    "        fake_preds = discriminator(fake_imgs)\n",
    "        real_loss = criterion(real_preds, real_labels)\n",
    "        fake_loss = criterion(fake_preds, fake_labels)\n",
    "        loss_D = real_loss + fake_loss\n",
    "        loss_D.backward()\n",
    "        optimizer_D.step()\n",
    "\n",
    "        # train generator\n",
    "        optimizer_G.zero_grad()\n",
    "        noise = torch.randn(batch_size, noise_dim).to(device)\n",
    "        fake_imgs = generator(noise)\n",
    "        fake_preds = discriminator(fake_imgs)\n",
    "        loss_G = criterion(fake_preds, real_labels)\n",
    "        loss_G.backward()\n",
    "        optimizer_G.step()\n",
    "\n",
    "    # print losses\n",
    "    if epoch % 50 == 0:\n",
    "        print('epoch: ', epoch, 'loss_D: ', loss_D.item(), 'loss_G: ', loss_G.item())"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [],
   "source": [
    "# generate some data\n",
    "noise = torch.randn(32, noise_dim).to(device)\n",
    "fake_imgs = generator(noise).detach().cpu().numpy()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAekAAAHqCAYAAAAgWrY5AAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjguMCwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy81sbWrAAAACXBIWXMAAA9hAAAPYQGoP6dpAAAmX0lEQVR4nO3dabSdZXk38CdkngdIwhRJZAgR1LZgRSZLo61gi2FhV4EuGUSlTrUMTohKV0ulJsX6gaFaC2KNy+Xqig1ShkAKERSEilARUBkykIQhIfM8vB9c7+tbrmvrc85zzj73Puf3+/hf93Pv++z9nH3lWbnOfQ/au3fv3goAKM4+fb0AACCnSANAoRRpACiUIg0AhVKkAaBQijQAFEqRBoBCKdIAUChFGgAKNaTuwEGDBvXmOhhAurvJnXuw+8aOHRuyjRs39sFKfmXIkPyrZ9euXSE7+OCDQ7ZixYpGr99ko8VOvg+ztdt0sp599onPtNl715X3s85YT9IAUChFGgAKpUgDQKEUaQAo1KC6R1V2crMEZentxrFW4/pbg0zWyLJnz562vX4nNyH1dONYJ78X9B2NYwDQwRRpACiUIg0AhVKkAaBQtXccg07Rqhkj2+Uq2+GqqXY1dLWrSeyP//iP0/yOO+5oy+s31Wp3s56U3XMDpYGR3uVJGgAKpUgDQKEUaQAolCINAIVSpAGgULYFpe1KOk963LhxIduwYUOjOW0RWT7nSf9aV94L93bPsi0oAHQwRRoACqVIA0ChFGkAKJRtQRnQmjaJZbLmmmyr0N27d/f4a8NvMmLEiJCNGjUqHXvuueeG7A1veEPIXv/614fs0EMPrb2mG2+8MWSXX355yLZt21Z7zhINGzasW9d5kgaAQinSAFAoRRoACqVIA0ChNI7R0caOHRuyjRs3pmPbdZ501jiWNYkNHz48vX7atGm1sn333Tdkhx9+eDrnGWecEbKsCSjTqrlu4sSJIRs8eHDIduzYEbLLLrssnfMb3/hGyNavX//blkgia1bMGroWLFiQXp81md1+++0hmzlzZsjGjBmTzpntsPWxj30sHftqV1xxRZpv2bKl1vV9Lfs9qMOTNAAUSpEGgEIp0gBQKEUaAAqlcexVHMXWWVo1iWV6o0kss2fPnpBNmDAhZJ/5zGfS688666yQHXTQQSFr15GJkydPTvPs58yyrJnslFNOSef85je/Wet6u7X9dpMmTQrZF7/4xZBNmTIlvX716tUhW7JkScj+5V/+JWTjx49P58zupaeffrrWuKxRsqo6p3GsuzxJA0ChFGkAKJQiDQCFUqQBoFCKNAAUakB0dx922GEh+9SnPpWOPfroo0O2ffv2kK1bty5ky5YtS+dcs2ZNyK688sp0LJ0l67DOtsv8whe+ELK3vvWt6ZxTp06t9Tq9Ieua3rp1azr25z//eciyLvb9998/ZM8880w6Z9apq5O7e6ZPnx6yE044IWTZdrlVVVX/+q//GrJbbrklZNn90eovKUaOHBmy7H7Pzo7etGlTOmd/50kaAAqlSANAoRRpACiUIg0Ahep3jWPZubu33npryEaNGpVef/XVV4ds5cqVIZs7d27ITj311HTOoUOHhuy//uu/Qnbvvfem19NZjj/++JC94x3vCNm4cePS67NtMLPmnOy84Mcffzydc+HChSG75pprQnbUUUeFbNWqVemca9euDVl2vveZZ54ZshUrVqRzZk2adY0ePTrNN2/e3O05O1nWfJU14WXfT63GZp9PV85JzsY+//zzIct+Bwbq5+hJGgAKpUgDQKEUaQAolCINAIUatLfmYcnt2vGoqf/8z/8MWbaL2N/93d+l13/lK1+p9TpZY8MFF1yQjr3hhhtClu1Ylu280x93W+ru+dy9cQ9mTTNZU+H69evT64cNGxay7KzkefPmhWzWrFnpnNlnvmDBgpBdfvnlIWvVkJXN2a57K2twGz58eDq21e5mPf36TX72TvkuzL6j5s+fH7I5c+ak13//+9+vNTbbJS77vaiqfPfHX/7ylyHLGsyys8o7XZ3vQk/SAFAoRRoACqVIA0ChFGkAKFRHN45lDT5Z40y2U80hhxySztkbzQlHHnlkyO67776QXXbZZSH7+te/3ui1u9uk1ZtKahzrDb/zO78TsjvuuCNkY8aMSa/P7sGTTjopZI899lita4ma/F50yn2Y+fM///OQfelLX0rH7ty5M2R/+Zd/GbLs+23GjBnpnFkDZtZUmR11mTWoVVWZ33GZ7L6p8/vqSRoACqVIA0ChFGkAKJQiDQCFUqQBoFAd3d19xhlnhOy6664L2ZVXXhmyVtt/9kan4L777huyu+66K2TZWdjLly9P58zOLM620itxW9H+3t39mte8JmRLliwJ2UEHHZRen50D/IEPfCBk//7v/x6yrpztO1Bk22Nm3cN1dcp9mMnO3H700UfTsdl93Ors6Vdr9f4uW7YsZEOGDAnZxIkTQ/b2t789nfPBBx+staYS2RYUADqYIg0AhVKkAaBQijQAFCr+j30H+cUvfhGyrOlmzZo1IWvnVnLZ2aqLFi0K2dlnnx2y733ve+mcWbNFb5zFS9dlzX633npryLItFqsqb875wz/8w5D9x3/8R8g0jkUlNk/2lazpbdy4cenYuk1i2daW2VnUVVVVjzzySMguvvjikGXfzxdddFE657PPPhuyF198MR3biTxJA0ChFGkAKJQiDQCFUqQBoFAd3Tj21FNPhWzSpEkhy86Ybqesce22224LWdZU8corr6Rzbtq0qfnCBph99on/Ju2N85ezppdnnnkmZNl5vVWVNxr+0R/9Ucje/OY3h+zoo49O51y4cGHIst2fOuVs3ky2s1hVdUbj2KhRo0LW6vzkJs4777yQtWocy2SNicccc0zIsvu9qvLv51NPPbXWuD/7sz+rs8Sqqqrqve99b+2xpfMkDQCFUqQBoFCKNAAUSpEGgEJ19FGV2Zp+/vOfh2z+/Pkh+/znP98ra8ocd9xxIZs7d27IsgazqVOnpnPOnj07ZL3RaNIbutuclDUGZXM1bX7K7qumcx5wwAEhe+KJJ9Kx48eP7/brtFrn/fffH7K/+Iu/CNnKlStD1uRYx1I1+TybfheefvrpIct298qOIm3qIx/5SMg+97nPpWOz5q9zzjmn1rimsu/Me+65Jx2bNYRmxwNv3Lix8bp6mqMqAaCDKdIAUChFGgAKpUgDQKEUaQAoVI93d2fbuVVVVa1du7b+qho466yzQnbZZZeF7H3ve196/aOPPlrrdUaMGBGyK664Ih2bnZeanXeabbm33377pXNecsklIbvpppvSsaXpbmdtiX9hUFe27eN///d/p2OPOOKIkGUdrF2RvefZlqjZVqGHHXZYOmdvbKnaLn3Z3d2Xsq7nb3/72+nYH/3oRyHL/iqm1fa2TQwfPjxkrbZCHjIk7m79u7/7uyH7yU9+0nhdPU13NwB0MEUaAAqlSANAoRRpAChUR28LmsnWedddd4XspJNOSq//wQ9+ELKtW7eGLNu2LmtgqKqq+p//+Z+QfehDHwrZa17zmpBdddVV6ZynnXZayJYvX56OLU1JjWPZ2c1ZA19T2dpnzZqVjv2TP/mTWnNeeumlIZs4cWI6Nrs3625/OmPGjHTOpUuX/rYlFqu0xrHe2Iq2riOPPDLNV69eHbL169eHrDfWmd2vP/vZz9Kxhx9+eMgefvjhkL3pTW9qvrAepnEMADqYIg0AhVKkAaBQijQAFKrfNY5lsnOIW+0OVvcM1+OPPz5kCxcuTMdmDRiZ7Bzh7HzsqqqqK6+8MmTXX399rdfpayU1jnWyrLnm7W9/ezo2O8P4/e9/f8iync0eeuihdM4zzjgjZNl51CUqrXGsXbLvwhNPPDEdm51B3q6zxbP3+HWve106NmvM3bx5c8jGjh3bfGE1tLo/sntO4xgAdDBFGgAKpUgDQKEUaQAo1IBoHOsUEyZMCFmrXcS+853vhOy9731vTy+pV3S3aSdramrXrkydYsyYMWme7WaXNUlmx1K2Ooow2/HsK1/5Ssh2796dXt+XBkLjWLbOadOmheyrX/1qev0TTzwRsuwz743PN1v7DTfckI698MILQ5btEjlu3LiQ9fX3h8YxAOhgijQAFEqRBoBCKdIAUChFGgAKlR+ATJ/Izmrdvn17OjY787gvz6Rth075WbIzqkeNGhWy7POuqvo/Z7YtaKtrs7Hz588P2Sc+8YmQjRw5Mp3z6quvDtm3vvWtkK1bty69vqcNHTo0zffs2dOW1+8E2baxxx57bDp25syZIbvuuutC1mrr4rqyrUrf9ra3hexd73pXen32vbdhw4aQdcr3x6t5kgaAQinSAFAoRRoACqVIA0ChNI4VJGtsePbZZ9Oxhx9+eMhGjx4dsk2bNjVfGC1lW5XOnj07ZFlD1uLFi9M5b7zxxpC98MILIcu2kT333HPTOf/gD/4gZCeddFLIsga37GdsNbYvtwBttX1paUaMGBGybdu29fjrZN8njz76aMhaNQZm59tfccUVIbv44otD9sorr6RzDh8+PGTZ78vNN98csmxbz6qqqhUrVoTs/PPPT8d2Ik/SAFAoRRoACqVIA0ChFGkAKJTGscIdddRRaZ41gJR4bm9vy5qaurLDVNNd2iZNmhSyY445plZ2wgknpHNmu0L91V/9VciyHaGuuuqqdM6sYaepn/70pyHrlOatvtQbTWJNXrvV/b5r166QZQ2IDz/8cMiy85yrKr8Ps7POs13IWn2/PfPMMyG7995707F11T0zvB27mHmSBoBCKdIAUChFGgAKpUgDQKE0jhUkO2ov252oqvIdx1o1a/RnTY8hbNr4kR0lOmXKlJBlDTOtjlY88cQTQ3bLLbeEbMyYMbVep6mXX345zefMmROygXiEaid5/vnnQ7ZmzZp0bLajXPZZZo1fWdNZVeUNYdnuZNnvxle/+tV0zssvvzxkdb8XWjWIlXR/epIGgEIp0gBQKEUaAAqlSANAoRRpACjUoL0129jqbpNG9w0ZEpvtN27cmI79wQ9+ELLsXNYSdbdzssR7MOtCnTp1asieeuqpkGXds70le8+zDtw77rgjZK3OqM7+8iDrFM46vvtak+7dEu/DurK1n3zyyenY7C8F3vWud4XslFNOCVmrLTyzrWTvvPPOkN1///0he/bZZ9M5O3kr2jr3oSdpACiUIg0AhVKkAaBQijQAFErjWEGy9/juu+9Oxy5btixk559/fk8vqVd0t2knOzu6pO37/q/sc5w4cWLInnzyyfT6rGEn284xayrMGnOqKm8qvPbaa0P2ta99LWStGnOyLVGzJrGsIbLVtpGZrLFpyZIlta/PDNTGMcqicQwAOpgiDQCFUqQBoFCKNAAUSuNY4a6++uo0f8973hOygw46qLeX0yP6045j/G9jx44NWatd8+qqex71oYceml7/9NNP17q+yXqgOzSOAUAHU6QBoFCKNAAUSpEGgEJpHKPtertxrNW4uq+b7Wy2Z8+eWtf2lrrNU9naW40tcbe2dmnys2c7qLU6mnEgKPH3pS9lx9dWVb5zn8YxAOhgijQAFEqRBoBCKdIAUChFGgAKFdsUocN1Stdyq07srDO27s/Uzq7avuzq7cvXblcnd9NzuLMu41ZngzfRG+/74MGDQ9YpHfSt3uNWXd+/jSdpACiUIg0AhVKkAaBQijQAFKr2tqAAQHt5kgaAQinSAFAoRRoACqVIA0ChFGkAKJQiDQCFUqQBoFCKNAAUSpEGgEIp0gBQKEUaAAqlSANAoRRpACiUIg0AhRpSd+CgQYN6cx1U+XvcH08S7e7P5B6kpzT5vXIf0lPq3IeepAGgUIo0ABRKkQaAQtX+P2l6X3/8/2dol1b/V+z3ik7mSRoACqVIA0ChFGkAKJQiDQCF0jgG9AsaxOiPPEkDQKEUaQAolCINAIVSpAGgUIo0ABSq33V3Dxs2LGQ7duzog5UAQDOepAGgUIo0ABRKkQaAQinSAFCoPm0cGzp0aMh27tzZaE5NYgBlOvroo0N24YUXhuzb3/52yB599NF0zq1btzZfWME8SQNAoRRpACiUIg0AhVKkAaBQfdo41rRJrK5BgwaFrMSzZ1/72teG7MMf/nA69o1vfGPIPvOZz4TswQcfbL4wuqRT7jfoLYMHD07zd77znSE7++yzQ/b444+HbKB+l3mSBoBCKdIAUChFGgAKpUgDQKE6+qjKIUPi8nft2hWyEpt2pk+fHrL77rsvZK0aMO68886QrVy5svG6aK7E+62JrBGuqvrfz0nPmTRpUpr/9V//dcjGjRsXsgMOOCBkA/V+8yQNAIVSpAGgUIo0ABRKkQaAQinSAFCoQXtrtsy16vCs/UIDYKvEffbJ/80za9askGXd2WPHjg3Z3/zN36Rzzp8/P2QvvvhiyHbv3p1e35e6+7k3vQd7Q7am2bNnh+zHP/5xyNavX5/OOWzYsFqvM2XKlJB95CMfSec855xzQjZ58uSQZX8x0eoeeutb3xqy+++/Px1bmibfPX15H7b6jtmzZ0+bV/KbLV68OM1POeWUkGX31z333BOyt73tbY3XVZo696EnaQAolCINAIVSpAGgUIo0ABSqbY1jA8HMmTPTfNGiRSHbf//9Q/bYY4+F7Pjjj0/n3LFjRxdXV47+1Dh22GGHheyRRx4J2dChQ0O2ZcuWdM41a9aEbPz48SHbb7/9QtbO9+j0008P2S233NK212+iUxvHSjRhwoSQvfzyy+nYbJvj7Pfg0EMPDdnq1au7vrj/T4nNyxrHAKCDKdIAUChFGgAKpUgDQKE6+jzp0nzyk59M84kTJ4bshRdeCNmll14ask5uEBsIsjO8hw8fHrKscSwbV1X5/ZI1mHSlgSlrzsnuwRkzZtR67aqqqmeffbbWmvq6OYfeddZZZ4UsaxBr5e677w7Z2rVrG62pP/EkDQCFUqQBoFCKNAAUSpEGgEJpHOum7Mi4U089NR2bNc5kTTcPPPBA84XRVtkRgc8991zI9t1335Bt3749nTNr6Jo3b17IJk2aFLJWOz1lR/+9+93vDtmXv/zlkLVq/Mqa0TSJDTyf+tSnGl2f/b7s3Lmz0ZyZTr03PUkDQKEUaQAolCINAIVSpAGgUIo0ABRKd3c3HXHEESHLum2rqqq2bt0asrlz54bMFqCdJ+vQftOb3hSyrFu1VXf37t27my/sVYYMib/q73//+2tdm/0lQlXlW6LSv2XbvnZle9rsryFuuOGGkHVqJ3Zv8CQNAIVSpAGgUIo0ABRKkQaAQmkcqyFrjHjPe94Tsqw5p6qqavPmzSFbvHhxyDqlWSI7G7k3tvHrBNlntn79+j5YyW/2jne8I2TZ2dGZn/3sZ2neqvGtHbJtebOmJHpW9r6PGTOm9vWvvPJKyFptZcuveJIGgEIp0gBQKEUaAAqlSANAoTSO1ZA1Rlx88cUha9X49elPfzpk27Zta76wPjJQm8Q62SGHHBKyESNGhGzXrl0hu+2229I5+7LRUZNY3xg/fnzIxo4dW/v6rPGsN3bY6088SQNAoRRpACiUIg0AhVKkAaBQGsdeJdtd7KabbgrZyJEjQ7Zly5Z0zltvvTVkmiXoDdOnT0/zSy65JGSDBw8O2fPPPx+yRYsWNV4X/cP1118fsuw+auXOO+8M2caNGxutqb/zJA0AhVKkAaBQijQAFEqRBoBCKdIAUKi2dXfPmTMnZN/97nfb9fK1DRs2LGQnnHBCrWtffPHFNN+0aVOjNUFdn/3sZ9P8wAMPDNmOHTtCdu2114bsl7/8ZfOF0XGyv3R5y1veErJse9hW2x5nf+mSbUXLr3mSBoBCKdIAUChFGgAKpUgDQKHa1ji2cOHCdr1UI9kZu3XP3f3CF76Qzpk16EBTkyZNCtns2bPTsUOGxF/1p59+OmTXXXdd84XRL2RnP2fbxh588MEha3XW+Lp162qP5Vc8SQNAoRRpACiUIg0AhVKkAaBQbWsc27NnT7teqpE3v/nNIRs9enTIsp9n8eLF6ZylNUZkDSFVVf8z+vrXvx6y8847r9Ga6LrsPZ82bVo6Nvtsv/GNb4Rsw4YNzRdGv5Cdeb9q1aqQZTuTZc22VVVVU6ZMCVn2fZS99kDlSRoACqVIA0ChFGkAKJQiDQCFalvjWKf46Ec/GrKsMWL79u0hW758ea+sqae1amTLGjiyhiNNYu03efLkkF1yySUha9UUuGXLlpB95zvfab4wBpTNmzfXGtfqO2bt2rUh65Sm4r7iSRoACqVIA0ChFGkAKJQiDQCFUqQBoFA93t2dbaFZVXlX4KhRo0KWdaH2hqxju6qq6vd+7/dqXf/AAw+ErFPOjW7VeVl3+9LsvStt69NONnjw4JCdeOKJITvwwAND1qpT9vbbbw9Zdp40/CaPPfZYyLLf/V27dqXXL1mypMfX1N95kgaAQinSAFAoRRoACqVIA0CherxxrO62cVXVviaxzLBhw9I8Oy81OwO17rmqVVVeU1XTdZb28/Q3U6dODdk//dM/hSzbAvTJJ59M57z00ktD5sxeumrmzJkhy74PNm3alF6fbW+b3Yfr1q3r+uL6KU/SAFAoRRoACqVIA0ChFGkAKFSjxrFsZ6ROaUYZO3Zsms+YMSNk2c+0YcOGkLU6y7e081I1fpVh5MiRaf7xj388ZNOmTQtZ9jkuWrQonXPlypVdXB0l6uvvmGzHsAsuuCBkrRpzH3rooZDdddddITvzzDNDVtr3aLt4kgaAQinSAFAoRRoACqVIA0ChGjWOdUqTWKbV2levXh2yCRMmhOwf//EfQ9bqeDbIZM1gVVVV73vf+2pdv379+pBdc8016dj+dm8OGRK/uvrbz5jp6+aprCEs28Gw1ZHFWbNj9ln29c9ZEk/SAFAoRRoACqVIA0ChFGkAKJQiDQCF6vHzpDvFvvvum+bZVo0jRowI2f777x+y5557rvG66urkLVkHoqFDh4Zs9uzZ6dgxY8aELPtsTzzxxJAtXbq0G6vrPAOhk7tE//Zv/xayL3/5yyFrtX1p9tczH/7wh5svrB/zJA0AhVKkAaBQijQAFEqRBoBCDdjGsbVr16b51q1bQ5Zte5c1bmXjqirfCi9rrOjKVnh92SSW/ZwlnVHdlTN327W9ZNaQ+Ld/+7e1r1+zZk3IHn/88UZrgq7atm1byFptAUrP8CQNAIVSpAGgUIo0ABRKkQaAQmkce5WjjjqqLa/fyeelltQklunKe9uunavOOOOMkI0bNy4du3PnzpCddtppPb4moHyepAGgUIo0ABRKkQaAQinSAFCoAds4Br0lawjLGtSWLVuWXv+tb30rZE899VTIHFcK/Z8naQAolCINAIVSpAGgUIo0ABRKkQaAQg3aW3OPx1ZnJdO/9cbZ0d293j04MJV0D1aV+5CeU+c+9CQNAIVSpAGgUIo0ABRKkQaAQtVuHAMA2suTNAAUSpEGgEIp0gBQKEUaAAqlSANAoRRpACiUIg0AhVKkAaBQijQAFEqRBoBCKdIAUChFGgAKpUgDQKEUaQAo1JC6AwcNGtSb62AA6e7pqL1xDx533HEhe+CBB3r8dShLkxN6fRfSU+rch56kAaBQijQAFEqRBoBCKdIAUKhBe2t2UGiWoKeU1DjGwKRxjBJoHAOADqZIA0ChFGkAKJQiDQCFqr3jGAxkgwcPTvPdu3e3eSXAQOJJGgAKpUgDQKEUaQAolCINAIVSpAGgULq7oQZd3EBf8CQNAIVSpAGgUIo0ABRKkQaAQmkcK9ynP/3pNP/Qhz4UshkzZoRsz549tTL6t6FDh4ZswoQJta596aWXeng19CfDhw8P2apVq9KxL7/8csi+9rWvhewf/uEfmi+sn/AkDQCFUqQBoFCKNAAUSpEGgEJpHCvcmDFj0nzIkPjRffKTnwzZ3LlzQ7Zjx47mC6Oj7Ny5M2Tjx48P2ZFHHhmyu+++O51z69atzRdGRxk0aFDIHn744ZBl91ZVVdXYsWNDduaZZ4bsuuuuC9nGjRvrLLHf8SQNAIVSpAGgUIo0ABRKkQaAQmkcK8gHP/jBkL3zne9Mx86bNy9kd9xxR8h27drVfGG0lDXSzJ8/P2Rnn312O5bT0siRI0P205/+NGSLFi0K2Re/+MV0zte97nXNF0ZHye73rEksG1dVVbXPPvG5MNspcfbs2SH77ne/W2OF/Y8naQAolCINAIVSpAGgUIo0ABRKkQaAQg3au3fv3loDW3TrtUN2Fm5V5Vsddopx48aF7LnnngtZ1g1ZVfn2jatXr268rnaoecsFfXkPtpKd9/33f//3Ievrta9bty5kWVduttXn4MGD0zmPOOKIkC1durTri+sD3b0Hq6rvP8u+lP3sTz/9dMiyju1Wsr9A+eEPfxiyk08+ufacnaLOfehJGgAKpUgDQKEUaQAolCINAIXqiG1BO7lBrKqqavjw4SG77bbbQjZhwoSQ/eIXv0jnXLNmTeN10Vx2hneJRo8eHbLsXPEVK1aEbNOmTemcWZ41OmbNMU0at+g7WRPhtGnTGs25e/fukH3uc59rNGd/4kkaAAqlSANAoRRpACiUIg0AheqIxrFO0WonorPOOitkr3/960OWNdPMnTs3nbPTm+n6i5tvvjlkH/3oR0N2wQUXhOzGG2/slTVlsh3Hsmayww8/PGQvvfRSOmd2D+7Zs6fri+uG888/P2Q33XRTW157IBs1alTImu7Atnbt2pA9/vjjjebsTzxJA0ChFGkAKJQiDQCFUqQBoFAax3rQsGHD0vyzn/1syMaMGROyH//4xyGbP39+84XRJXWPcKyqqrroootqzZntJtdODz30UMhOPfXUWtfec889ad5qJ7J20CTWN8aOHRuyVkeZNpnTjoq/5kkaAAqlSANAoRRpACiUIg0AhVKkAaBQurt70LHHHpvmhxxySMiyLRUvv/zykG3ZsqX5wuiSbdu2hexLX/pSOnbo0KEhyzrBFyxY0HxhDRx33HG1xmX32znnnJOObdcWoJTj3e9+d8iy86C70vGd/VWMe+vXPEkDQKEUaQAolCINAIVSpAGgUBrHuilrjPje976Xjt1nn/hvoXvvvTdkd911V/OF0djIkSND1qqBLzsD/MILLwxZtoVmdl9UVbOmmf322y/Ns21oM1nTXNYYRP+XNXTNmTMnZE23Bd2xY0ej6/s7T9IAUChFGgAKpUgDQKEUaQAolMaxbrryyitDlp1DXFVVtW7dulrX22WnDNnn9YlPfCIdO2LEiJD96Z/+aciuvvrqkB144IHpnNdff33Ibr755pDNnDkzZPPmzUvnzHZGy0yaNClkrZrONm7cWGtOOtOuXbtCNmjQoD5YycDmSRoACqVIA0ChFGkAKJQiDQCFGrQ32zIpGziAGwZe+9rXhuz73/9+yFo1Ap133nkh++Y3vxmygbKzU81bLijxHrzgggtCdtVVV4Vs9OjRIRs3blyvrKmnbd++Pc0//vGPh+yaa64J2cqVK0O2dOnSdM6TTz65i6vrnu7eg1VV5n3YG7Kfc8WKFSFr9b1XV9aoOXHixEZzdoo696EnaQAolCINAIVSpAGgUIo0ABRKkQaAQtkW9FWyrT3vu+++kO2///4ha9UFu3DhwpANlE7u/qJVR+8TTzwRstNOOy1kCxYsCFmr7TZbnTPdV7Lu26rKO33vueeekE2fPj1kw4cPb7gqelu2RezkyZMbzZl1Mw+UbvnuKuvbAAD4fxRpACiUIg0AhVKkAaBQA7ZxrFWzwqxZs0I2ZcqUWnPOmTMnzTds2FB7XZSp1fZ9DzzwQK3rZ8yYEbLLLrssHXvuueeGbPDgwSGbMGFCyA444IB0zux+z36mRx55JGTHHntsOmd2fdYgR2fKzrdv2tSY3YfLly9vNGd/50kaAAqlSANAoRRpACiUIg0AhRqw50lnuyBVVX5O9MEHHxyyV155JWRHHXVUOueqVau6trh+rj+dJ93EIYcckubZTmQf+MAHQrZjx46QXXrppemcdd+7nTt3hizbXa+qqmrt2rW15iyR86R/u6wxMfvea+otb3lLyOo2ZDbV6rNscn90hfOkAaCDKdIAUChFGgAKpUgDQKEG7I5jxx13XJpnOzZl/7l/4403huyll15qvrAGst2Asl2DKMPSpUvTfNSoUSH72Mc+FrKhQ4eGrFXjWBPZa1dVVX3+85/v8deiHL//+7/f43Nm30c/+tGPevx16ho7dmyal7RLpCdpACiUIg0AhVKkAaBQijQAFEqRBoBCDYhtQSdNmhSyxYsXp2Pf+MY3hmzJkiUhO/3000O2fv36bqyud5XY8W1b0F8ZMiT/44pdu3Z1e85t27al+fDhw2tdn90breYcPXp0/YUVxragv90HP/jBkF177bUh68r7kXVNZ9uPtmtbzmHDhqV5tuVub7AtKAB0MEUaAAqlSANAoRRpACjUgGgcmz17dsgWLFiQjs3OSz3zzDND9pOf/CRkTRp+BpKebBzLsnY1nfS1bPvQzZs3N5rzxRdfDNk555yTjr377rsbvVZf0jj2202ZMiVky5cvD1mr5qtMdl751KlTQ9Yb51aXSOMYAHQwRRoACqVIA0ChFGkAKFS/O0/6DW94Q8guuuiikGVNN1VVVT/84Q9Dlp37q0msDAOlSSyz33779fichx12WMg2btzY46/TykBuBCzNSy+9FLLdu3c3mnPw4MEhmzx5csgGSuNYHZ6kAaBQijQAFEqRBoBCKdIAUKh+1zg2b968kB177LEhW7VqVXr9bbfdFrKXX365+cKgh915552Nrt++fXvI2tkkltEkVo7ss+jK7mKZrAl32bJljebs7zxJA0ChFGkAKJQiDQCFUqQBoFCKNAAUqt91d48ePTpk2Rmmt99+e3p9qxxKc+ihh9Yem3XqTp8+vQdX0162D+0bxxxzTMgefPDBkK1YsSK9/p//+Z9DZovl38yTNAAUSpEGgEIp0gBQKEUaAAo1aG/NbousUQO6o7sNPu7B/60r7+OTTz4ZslmzZvXkcjpKkyYz9yE9pc596EkaAAqlSANAoRRpACiUIg0AhdI4RttpHOsZkyZNCtkLL7yQjp04cWLINm3a1ONr6hQaxyiBxjEA6GCKNAAUSpEGgEIp0gBQKI1jtJ3GMfqaxjFKoHEMADqYIg0AhVKkAaBQijQAFEqRBoBCKdIAUChFGgAKpUgDQKEUaQAolCINAIWqvS0oANBenqQBoFCKNAAUSpEGgEIp0gBQKEUaAAqlSANAoRRpACiUIg0AhVKkAaBQ/wevVxig07Tz2gAAAABJRU5ErkJggg==",
      "text/plain": [
       "<Figure size 500x500 with 9 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "# visualize some generated data, 3x3 grid\n",
    "fig, axs = plt.subplots(3,3, figsize=(5,5))\n",
    "axs = axs.flatten()\n",
    "for i in range(9):\n",
    "    axs[i].imshow(fake_imgs[i].reshape(28,28), cmap='gray')\n",
    "    axs[i].axis('off')\n",
    "plt.tight_layout()\n",
    "plt.show()\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "```\n",
    "Nice!\n",
    "```"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "torch",
   "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.11.5"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}