evaluating_GAN_generator.ipynb

{
  "cells": [
    {
      "cell_type": "code",
      "execution_count": 74,
      "metadata": {
        "id": "LyRZXR9SYC_L"
      },
      "outputs": [],
      "source": [
        "import os\n",
        "import numpy as np\n",
        "import torch\n",
        "import torchvision\n",
        "from torchvision import transforms\n",
        "import torch.nn as nn\n",
        "import matplotlib.pyplot as plt"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 81,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "AEyQhp7TORcx",
        "outputId": "84f7070f-0278-421d-9c73-3f1727475b16"
      },
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "Using 'cpu' device.\n"
          ]
        },
        {
          "data": {
            "text/plain": [
              "<All keys matched successfully>"
            ]
          },
          "execution_count": 81,
          "metadata": {},
          "output_type": "execute_result"
        }
      ],
      "source": [
        "class Generator(nn.Module):\n",
        "    def __init__(self, input_size, n_filters):\n",
        "        super().__init__()\n",
        "\n",
        "        self.network = nn.Sequential(\n",
        "            nn.ConvTranspose2d(input_size, n_filters, 3, 1, 0, bias=False),\n",
        "            nn.BatchNorm2d(n_filters),\n",
        "            nn.LeakyReLU(0.2),\n",
        "            nn.ConvTranspose2d(n_filters, n_filters // 2, 3, 2, 0, bias=False),\n",
        "            nn.BatchNorm2d(n_filters // 2),\n",
        "            nn.LeakyReLU(0.2),\n",
        "            nn.ConvTranspose2d(n_filters // 2, n_filters // 4, 4, 2, 1, bias=False),\n",
        "            nn.BatchNorm2d(n_filters // 4),\n",
        "            nn.LeakyReLU(0.2),\n",
        "            nn.ConvTranspose2d(n_filters // 4, 1, 4, 2, 1, bias=False),\n",
        "            nn.Tanh()\n",
        "        )\n",
        "\n",
        "\n",
        "    def forward(self, x):\n",
        "        'Forward pass'\n",
        "        output = self.network(x)\n",
        "        return output\n",
        "\n",
        "# Generate noise from normal distribution\n",
        "def create_noise(batch_size, z_size):\n",
        "    input_z = torch.normal(0.0, 1.0, (batch_size, z_size, 1, 1))\n",
        "    return input_z\n",
        "\n",
        "\n",
        "torch.manual_seed(1)\n",
        "\n",
        "# Download and load the training set\n",
        "transform = transforms.Compose([transforms.ToTensor(), transforms.Normalize(mean=(0.5), std=(0.5))])\n",
        "trainset = torchvision.datasets.MNIST(root=\"data\", download=True, transform = transform)\n",
        "\n",
        "# Create a DataLoader to efficiently load the data in Instancees\n",
        "batch_size = 64\n",
        "data_loader = torch.utils.data.DataLoader(trainset, batch_size=batch_size, shuffle=True, drop_last = True)\n",
        "\n",
        "device = \"cuda\" if torch.cuda.is_available() else \"cpu\"\n",
        "print(f\"Using '{device}' device.\")\n",
        "\n",
        "gen_input_size = 100\n",
        "image_size = (28, 28)\n",
        "n_filters_gen = 128\n",
        "n_filters_dis = 128\n",
        "\n",
        "generator = Generator(100, n_filters_gen)\n",
        "generator.load_state_dict(torch.load(\"/content/gen-params-100\", map_location=torch.device('cpu')))\n"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 84,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 447
        },
        "id": "2naL9Nm6Pu0d",
        "outputId": "96c9e094-5db6-4c69-c104-718ca9683032"
      },
      "outputs": [
        {
          "data": {
            "text/plain": [
              "<matplotlib.image.AxesImage at 0x78868bcf9f60>"
            ]
          },
          "execution_count": 84,
          "metadata": {},
          "output_type": "execute_result"
        },
        {
          "data": {
            "image/png": "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",
            "text/plain": [
              "<Figure size 640x480 with 1 Axes>"
            ]
          },
          "metadata": {},
          "output_type": "display_data"
        }
      ],
      "source": [
        "noise = create_noise(1, 100)\n",
        "image = generator(noise).squeeze().detach().numpy()\n",
        "image = (image * 0.5) + 0.5\n",
        "\n",
        "# print(noise[0][0][0][0].item())\n",
        "plt.imshow(image)"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 85,
      "metadata": {
        "id": "MKfcupLyQBpK"
      },
      "outputs": [],
      "source": [
        "# Download and load the training set\n",
        "transform = transforms.Compose([transforms.ToTensor(), transforms.Normalize(mean=(0.5), std=(0.5))]) #changed from og code transform = transforms.Compose([transforms.ToTensor()])\n",
        "testset = torchvision.datasets.MNIST(root=\"data\", train=False, download=True, transform=transform)\n",
        "\n",
        "# Create a DataLoader to efficiently load the data in Instancees\n",
        "test_loader = torch.utils.data.DataLoader(testset, batch_size=1, shuffle=True, drop_last = True)"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 87,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 447
        },
        "id": "DhY7mcsiYC_R",
        "outputId": "89687c63-422c-4a50-fdc1-13a242e4659b"
      },
      "outputs": [
        {
          "data": {
            "text/plain": [
              "<matplotlib.image.AxesImage at 0x78868ea0cfd0>"
            ]
          },
          "execution_count": 87,
          "metadata": {},
          "output_type": "execute_result"
        },
        {
          "data": {
            "image/png": "iVBORw0KGgoAAAANSUhEUgAAAaAAAAGdCAYAAABU0qcqAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjcuMSwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy/bCgiHAAAACXBIWXMAAA9hAAAPYQGoP6dpAAAa5ElEQVR4nO3dcWzU9f3H8dcB5QBtj9XaXm+UroCKE6kZg9ogHY6G0iUGkD9AXQRDcLBiBsxpWBRkW9INEzSaDvbHRkciyEwEotlYtNh2bi0LCCFkW0ObTiDQMkm4K0VKoZ/fH/w8PWjBO+76vjuej+Sb0Lvvt/f2u68+9+0dn3qcc04AAAyyIdYDAABuTwQIAGCCAAEATBAgAIAJAgQAMEGAAAAmCBAAwAQBAgCYGGY9wLX6+vp06tQpZWZmyuPxWI8DAIiSc05dXV0KBAIaMmTg+5ykC9CpU6dUUFBgPQYA4BadOHFCY8aMGfD5pAtQZmamJOkR/UDDlGE8DQAgWpfVq4/15/B/zweSsADV1NTo1VdfVUdHh4qLi/Xmm29q2rRpNz3uix+7DVOGhnkIEACknP9fYfRmb6Mk5EMIO3fu1Jo1a7R+/Xp98sknKi4uVkVFhc6cOZOIlwMApKCEBGjTpk1atmyZnnnmGX3729/Wli1bNGrUKP3hD39IxMsBAFJQ3AN06dIlHTx4UOXl5V++yJAhKi8vV1NT03X79/T0KBQKRWwAgPQX9wB99tlnunLlivLy8iIez8vLU0dHx3X7V1dXy+fzhTc+AQcAtwfzv4i6du1aBYPB8HbixAnrkQAAgyDun4LLycnR0KFD1dnZGfF4Z2en/H7/dft7vV55vd54jwEASHJxvwMaPny4pkyZorq6uvBjfX19qqurU2lpabxfDgCQohLy94DWrFmjxYsX67vf/a6mTZum119/Xd3d3XrmmWcS8XIAgBSUkAAtXLhQ//vf/7Ru3Tp1dHTooYce0t69e6/7YAIA4Pblcc456yG+KhQKyefzaabmshICAKSgy65X9dqjYDCorKysAfcz/xQcAOD2RIAAACYIEADABAECAJggQAAAEwQIAGCCAAEATBAgAIAJAgQAMEGAAAAmCBAAwAQBAgCYIEAAABMECABgggABAEwQIACACQIEADBBgAAAJggQAMAEAQIAmCBAAAATBAgAYIIAAQBMECAAgAkCBAAwQYAAACYIEADABAECAJggQAAAEwQIAGCCAAEATBAgAIAJAgQAMEGAAAAmCBAAwAQBAgCYIEAAABMECABgggABAEwMsx4AABLtwvySmI77W83voj5m/M7lUR8zYXVz1MekA+6AAAAmCBAAwAQBAgCYIEAAABMECABgggABAEwQIACACQIEADBBgAAAJggQAMAEAQIAmCBAAAATLEYKIKXEsrBoLIuKxqpt4Zaoj6lY/VD8B0kB3AEBAEwQIACAibgH6JVXXpHH44nYJk6cGO+XAQCkuIS8B/TAAw/oww8//PJFhvFWEwAgUkLKMGzYMPn9/kR8awBAmkjIe0DHjh1TIBDQuHHj9NRTT+n48eMD7tvT06NQKBSxAQDSX9wDVFJSotraWu3du1ebN29We3u7ZsyYoa6urn73r66uls/nC28FBQXxHgkAkIQ8zjmXyBc4d+6cCgsLtWnTJi1duvS653t6etTT0xP+OhQKqaCgQDM1V8M8GYkcDUAKSva/BxSLisBD1iPE1WXXq3rtUTAYVFZW1oD7JfzTAaNHj9a9996r1tbWfp/3er3yer2JHgMAkGQS/veAzp8/r7a2NuXn5yf6pQAAKSTuAXr++efV0NCg//73v/rHP/6h+fPna+jQoXriiSfi/VIAgBQW9x/BnTx5Uk888YTOnj2ru+++W4888oiam5t19913x/ulAAApLO4Bevvtt+P9LQGkqdbXHo76mFgW+xxM43cuj/qYCWpOwCTJj7XgAAAmCBAAwAQBAgCYIEAAABMECABgggABAEwQIACACQIEADBBgAAAJggQAMAEAQIAmCBAAAATCf+FdABuDywsetWE1bfnwqKx4A4IAGCCAAEATBAgAIAJAgQAMEGAAAAmCBAAwAQBAgCYIEAAABMECABgggABAEwQIACACQIEADBBgAAAJlgNG0nvwvySqI/5W83vYnqtpz8ti/qYztJQTK+VzNJtZetY/neVWNk60bgDAgCYIEAAABMECABgggABAEwQIACACQIEADBBgAAAJggQAMAEAQIAmCBAAAATBAgAYIIAAQBMsBgpkl6sC4vGYlthY9THzJj/o6iPGbVrf9THDKZkXlh0/M7lUR/DoqLJiTsgAIAJAgQAMEGAAAAmCBAAwAQBAgCYIEAAABMECABgggABAEwQIACACQIEADBBgAAAJggQAMAEi5EiZhfml0R9zGAuLDpYknlh0bymLOsRbujpT8uiPoaFRdMHd0AAABMECABgIuoANTY26rHHHlMgEJDH49Hu3bsjnnfOad26dcrPz9fIkSNVXl6uY8eOxWteAECaiDpA3d3dKi4uVk1NTb/Pb9y4UW+88Ya2bNmi/fv364477lBFRYUuXrx4y8MCANJH1B9CqKysVGVlZb/POef0+uuv66WXXtLcuXMlSdu2bVNeXp52796tRYsW3dq0AIC0Edf3gNrb29XR0aHy8vLwYz6fTyUlJWpqaur3mJ6eHoVCoYgNAJD+4hqgjo4OSVJeXl7E43l5eeHnrlVdXS2fzxfeCgoK4jkSACBJmX8Kbu3atQoGg+HtxIkT1iMBAAZBXAPk9/slSZ2dnRGPd3Z2hp+7ltfrVVZWVsQGAEh/cQ1QUVGR/H6/6urqwo+FQiHt379fpaWl8XwpAECKi/pTcOfPn1dra2v46/b2dh0+fFjZ2dkaO3asVq1apV/96le65557VFRUpJdfflmBQEDz5s2L59wAgBQXdYAOHDigRx99NPz1mjVrJEmLFy9WbW2tXnjhBXV3d+vZZ5/VuXPn9Mgjj2jv3r0aMWJE/KYGAKQ8j3POWQ/xVaFQSD6fTzM1V8M8Gdbj4AZiWehyW2FjAia5XiyLXEpSZ2ny/jWAdFz8tSLwkPUISIDLrlf12qNgMHjD9/XNPwUHALg9ESAAgAkCBAAwQYAAACYIEADABAECAJggQAAAEwQIAGCCAAEATBAgAIAJAgQAMEGAAAAmCBAAwETUv44B6SeWVa2lwVvZOhbtG++P6bhR2h/nSfqXjitbj9+5POpjJqg5AZMgVXAHBAAwQYAAACYIEADABAECAJggQAAAEwQIAGCCAAEATBAgAIAJAgQAMEGAAAAmCBAAwAQBAgCYYDHSNBPLIpfbCpN7kcsZVT+K+phRuwZnUdFYnSrzWI9wQ09/Whb1MRNWs7AoosMdEADABAECAJggQAAAEwQIAGCCAAEATBAgAIAJAgQAMEGAAAAmCBAAwAQBAgCYIEAAABMECABggsVI08zfapJ7YdFYFrlM9oVFY1kAtm3hlgRMYiuvKSvqY7YVNiZgkuvFsqCtlPzXXqrjDggAYIIAAQBMECAAgAkCBAAwQYAAACYIEADABAECAJggQAAAEwQIAGCCAAEATBAgAIAJAgQAMOFxzjnrIb4qFArJ5/NppuZqmCfDehxTra89HPUx6bjIZSxiWfRUGrzFMZEaKgIPWY+Qki67XtVrj4LBoLKyBl6kljsgAIAJAgQAMBF1gBobG/XYY48pEAjI4/Fo9+7dEc8vWbJEHo8nYpszZ0685gUApImoA9Td3a3i4mLV1NQMuM+cOXN0+vTp8LZjx45bGhIAkH6i/o2olZWVqqysvOE+Xq9Xfr8/5qEAAOkvIe8B1dfXKzc3V/fdd59WrFihs2fPDrhvT0+PQqFQxAYASH9xD9CcOXO0bds21dXV6Te/+Y0aGhpUWVmpK1eu9Lt/dXW1fD5feCsoKIj3SACAJBT1j+BuZtGiReE/P/jgg5o8ebLGjx+v+vp6zZo167r9165dqzVr1oS/DoVCRAgAbgMJ/xj2uHHjlJOTo9bW1n6f93q9ysrKitgAAOkv4QE6efKkzp49q/z8/ES/FAAghUT9I7jz589H3M20t7fr8OHDys7OVnZ2tjZs2KAFCxbI7/erra1NL7zwgiZMmKCKioq4Dg4ASG1RB+jAgQN69NFHw19/8f7N4sWLtXnzZh05ckR//OMfde7cOQUCAc2ePVu//OUv5fV64zc1ACDlRR2gmTNn6kbrl/71r3+9pYHwpUBjDOvELoz/HKmIRUWB5MdacAAAEwQIAGCCAAEATBAgAIAJAgQAMEGAAAAmCBAAwAQBAgCYIEAAABMECABgggABAEwQIACACQIEADAR91/JjfgZtWt/1MfM0I+iPuZvNb+L+hikhqc/LYvpuMFaTXz8zuVRH9O2cEvUx8yoiv7fC0kapej/HcTXxx0QAMAEAQIAmCBAAAATBAgAYIIAAQBMECAAgAkCBAAwQYAAACYIEADABAECAJggQAAAEwQIAGDC45xz1kN8VSgUks/n00zN1TBPhvU4SAKtrz0c9TGxLFg5mGJZJLR94/1RHxPLgrbArbrselWvPQoGg8rKyhpwP+6AAAAmCBAAwAQBAgCYIEAAABMECABgggABAEwQIACACQIEADBBgAAAJggQAMAEAQIAmCBAAAATw6wHAG5mwurm6A9aGP854omFRQHugAAARggQAMAEAQIAmCBAAAATBAgAYIIAAQBMECAAgAkCBAAwQYAAACYIEADABAECAJggQAAAEyxGiqR3YX5JDEcdjvcYA3r607Koj2FhUYA7IACAEQIEADARVYCqq6s1depUZWZmKjc3V/PmzVNLS0vEPhcvXlRVVZXuuusu3XnnnVqwYIE6OzvjOjQAIPVFFaCGhgZVVVWpublZH3zwgXp7ezV79mx1d3eH91m9erXee+89vfPOO2poaNCpU6f0+OOPx31wAEBqi+pDCHv37o34ura2Vrm5uTp48KDKysoUDAb1+9//Xtu3b9f3v/99SdLWrVt1//33q7m5WQ8//HD8JgcApLRbeg8oGAxKkrKzsyVJBw8eVG9vr8rLy8P7TJw4UWPHjlVTU1O/36Onp0ehUChiAwCkv5gD1NfXp1WrVmn69OmaNGmSJKmjo0PDhw/X6NGjI/bNy8tTR0dHv9+nurpaPp8vvBUUFMQ6EgAghcQcoKqqKh09elRvv/32LQ2wdu1aBYPB8HbixIlb+n4AgNQQ019EXblypd5//301NjZqzJgx4cf9fr8uXbqkc+fORdwFdXZ2yu/39/u9vF6vvF5vLGMAAFJYVHdAzjmtXLlSu3bt0r59+1RUVBTx/JQpU5SRkaG6urrwYy0tLTp+/LhKS0vjMzEAIC1EdQdUVVWl7du3a8+ePcrMzAy/r+Pz+TRy5Ej5fD4tXbpUa9asUXZ2trKysvTcc8+ptLSUT8ABACJEFaDNmzdLkmbOnBnx+NatW7VkyRJJ0muvvaYhQ4ZowYIF6unpUUVFhX7729/GZVgAQPqIKkDOuZvuM2LECNXU1KimpibmoYCvKnrh39Yj3NDfm78d9TET1JyASYDUwlpwAAATBAgAYIIAAQBMECAAgAkCBAAwQYAAACYIEADABAECAJggQAAAEwQIAGCCAAEATBAgAIAJAgQAMBHTb0QFBtO2wkbrEW4o0HjzVeIBXI87IACACQIEADBBgAAAJggQAMAEAQIAmCBAAAATBAgAYIIAAQBMECAAgAkCBAAwQYAAACYIEADABIuRIuk9/WlZ1MfEuoDp+J3Loz5mwq7mmF4LuN1xBwQAMEGAAAAmCBAAwAQBAgCYIEAAABMECABgggABAEwQIACACQIEADBBgAAAJggQAMAEAQIAmGAxUiS9ztJQ1MdU6KGYXmuCWFgUGCzcAQEATBAgAIAJAgQAMEGAAAAmCBAAwAQBAgCYIEAAABMECABgggABAEwQIACACQIEADBBgAAAJggQAMAEAQIAmCBAAAATUQWourpaU6dOVWZmpnJzczVv3jy1tLRE7DNz5kx5PJ6Ibfny5XEdGgCQ+qIKUENDg6qqqtTc3KwPPvhAvb29mj17trq7uyP2W7ZsmU6fPh3eNm7cGNehAQCpL6rfiLp3796Ir2tra5Wbm6uDBw+qrKws/PioUaPk9/vjMyEAIC3d0ntAwWBQkpSdnR3x+FtvvaWcnBxNmjRJa9eu1YULFwb8Hj09PQqFQhEbACD9RXUH9FV9fX1atWqVpk+frkmTJoUff/LJJ1VYWKhAIKAjR47oxRdfVEtLi959991+v091dbU2bNgQ6xgAgBTlcc65WA5csWKF/vKXv+jjjz/WmDFjBtxv3759mjVrllpbWzV+/Pjrnu/p6VFPT0/461AopIKCAs3UXA3zZMQyGgDA0GXXq3rtUTAYVFZW1oD7xXQHtHLlSr3//vtqbGy8YXwkqaSkRJIGDJDX65XX641lDABACosqQM45Pffcc9q1a5fq6+tVVFR002MOHz4sScrPz49pQABAeooqQFVVVdq+fbv27NmjzMxMdXR0SJJ8Pp9GjhyptrY2bd++XT/4wQ9011136ciRI1q9erXKyso0efLkhPwDAABSU1TvAXk8nn4f37p1q5YsWaITJ07ohz/8oY4eParu7m4VFBRo/vz5eumll274c8CvCoVC8vl8vAcEACkqIe8B3axVBQUFamhoiOZbAgBuU6wFBwAwQYAAACYIEADABAECAJggQAAAEwQIAGCCAAEATBAgAIAJAgQAMEGAAAAmCBAAwAQBAgCYIEAAABMECABgggABAEwQIACACQIEADBBgAAAJggQAMAEAQIAmCBAAAATBAgAYIIAAQBMECAAgAkCBAAwMcx6gGs55yRJl9UrOeNhAABRu6xeSV/+93wgSRegrq4uSdLH+rPxJACAW9HV1SWfzzfg8x53s0QNsr6+Pp06dUqZmZnyeDwRz4VCIRUUFOjEiRPKysoymtAe5+EqzsNVnIerOA9XJcN5cM6pq6tLgUBAQ4YM/E5P0t0BDRkyRGPGjLnhPllZWbf1BfYFzsNVnIerOA9XcR6usj4PN7rz+QIfQgAAmCBAAAATKRUgr9er9evXy+v1Wo9iivNwFefhKs7DVZyHq1LpPCTdhxAAALeHlLoDAgCkDwIEADBBgAAAJggQAMBEygSopqZG3/rWtzRixAiVlJTon//8p/VIg+6VV16Rx+OJ2CZOnGg9VsI1NjbqscceUyAQkMfj0e7duyOed85p3bp1ys/P18iRI1VeXq5jx47ZDJtANzsPS5Ysue76mDNnjs2wCVJdXa2pU6cqMzNTubm5mjdvnlpaWiL2uXjxoqqqqnTXXXfpzjvv1IIFC9TZ2Wk0cWJ8nfMwc+bM666H5cuXG03cv5QI0M6dO7VmzRqtX79en3zyiYqLi1VRUaEzZ85YjzboHnjgAZ0+fTq8ffzxx9YjJVx3d7eKi4tVU1PT7/MbN27UG2+8oS1btmj//v264447VFFRoYsXLw7ypIl1s/MgSXPmzIm4Pnbs2DGIEyZeQ0ODqqqq1NzcrA8++EC9vb2aPXu2uru7w/usXr1a7733nt555x01NDTo1KlTevzxxw2njr+vcx4kadmyZRHXw8aNG40mHoBLAdOmTXNVVVXhr69cueICgYCrrq42nGrwrV+/3hUXF1uPYUqS27VrV/jrvr4+5/f73auvvhp+7Ny5c87r9bodO3YYTDg4rj0Pzjm3ePFiN3fuXJN5rJw5c8ZJcg0NDc65q//bZ2RkuHfeeSe8z7///W8nyTU1NVmNmXDXngfnnPve977nfvKTn9gN9TUk/R3QpUuXdPDgQZWXl4cfGzJkiMrLy9XU1GQ4mY1jx44pEAho3Lhxeuqpp3T8+HHrkUy1t7ero6Mj4vrw+XwqKSm5La+P+vp65ebm6r777tOKFSt09uxZ65ESKhgMSpKys7MlSQcPHlRvb2/E9TBx4kSNHTs2ra+Ha8/DF9566y3l5ORo0qRJWrt2rS5cuGAx3oCSbjHSa3322We6cuWK8vLyIh7Py8vTf/7zH6OpbJSUlKi2tlb33XefTp8+rQ0bNmjGjBk6evSoMjMzrccz0dHRIUn9Xh9fPHe7mDNnjh5//HEVFRWpra1NP//5z1VZWammpiYNHTrUery46+vr06pVqzR9+nRNmjRJ0tXrYfjw4Ro9enTEvul8PfR3HiTpySefVGFhoQKBgI4cOaIXX3xRLS0tevfddw2njZT0AcKXKisrw3+ePHmySkpKVFhYqD/96U9aunSp4WRIBosWLQr/+cEHH9TkyZM1fvx41dfXa9asWYaTJUZVVZWOHj16W7wPeiMDnYdnn302/OcHH3xQ+fn5mjVrltra2jR+/PjBHrNfSf8juJycHA0dOvS6T7F0dnbK7/cbTZUcRo8erXvvvVetra3Wo5j54hrg+rjeuHHjlJOTk5bXx8qVK/X+++/ro48+ivj1LX6/X5cuXdK5c+ci9k/X62Gg89CfkpISSUqq6yHpAzR8+HBNmTJFdXV14cf6+vpUV1en0tJSw8nsnT9/Xm1tbcrPz7cexUxRUZH8fn/E9REKhbR///7b/vo4efKkzp49m1bXh3NOK1eu1K5du7Rv3z4VFRVFPD9lyhRlZGREXA8tLS06fvx4Wl0PNzsP/Tl8+LAkJdf1YP0piK/j7bffdl6v19XW1rp//etf7tlnn3WjR492HR0d1qMNqp/+9Keuvr7etbe3u7///e+uvLzc5eTkuDNnzliPllBdXV3u0KFD7tChQ06S27Rpkzt06JD79NNPnXPO/frXv3ajR492e/bscUeOHHFz5851RUVF7vPPPzeePL5udB66urrc888/75qamlx7e7v78MMP3Xe+8x13zz33uIsXL1qPHjcrVqxwPp/P1dfXu9OnT4e3CxcuhPdZvny5Gzt2rNu3b587cOCAKy0tdaWlpYZTx9/NzkNra6v7xS9+4Q4cOODa29vdnj173Lhx41xZWZnx5JFSIkDOOffmm2+6sWPHuuHDh7tp06a55uZm65EG3cKFC11+fr4bPny4++Y3v+kWLlzoWltbrcdKuI8++shJum5bvHixc+7qR7Fffvlll5eX57xer5s1a5ZraWmxHToBbnQeLly44GbPnu3uvvtul5GR4QoLC92yZcvS7v+k9ffPL8lt3bo1vM/nn3/ufvzjH7tvfOMbbtSoUW7+/Pnu9OnTdkMnwM3Ow/Hjx11ZWZnLzs52Xq/XTZgwwf3sZz9zwWDQdvBr8OsYAAAmkv49IABAeiJAAAATBAgAYIIAAQBMECAAgAkCBAAwQYAAACYIEADABAECAJggQAAAEwQIAGCCAAEATPwff+WeKhZf5BkAAAAASUVORK5CYII=",
            "text/plain": [
              "<Figure size 640x480 with 1 Axes>"
            ]
          },
          "metadata": {},
          "output_type": "display_data"
        }
      ],
      "source": [
        "image_real, label = next(iter(data_loader))\n",
        "image_real = image_real.squeeze().detach().numpy()\n",
        "plt.imshow(image_real[0])"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "RHdQSmYlQW0m"
      },
      "outputs": [],
      "source": [
        "# @title Default title text\n",
        "from pytorch_fid import fid_score\n",
        "from pytorch_fid.fid_score import calculate_fid_given_paths\n",
        "\n",
        "#Makeing folders for real and fake images\n",
        "current_dir = os.getcwd()\n",
        "real_images_folder_name = 'real_images'\n",
        "fake_images_folder_name = 'fake_images'\n",
        "\n",
        "real_images_folder = os.path.join(current_dir, real_images_folder_name)\n",
        "fake_images_folder = os.path.join(current_dir, fake_images_folder_name)\n",
        "\n",
        "# Save real images\n",
        "os.makedirs(real_images_folder, exist_ok=True)\n",
        "os.makedirs(fake_images_folder, exist_ok=True)\n",
        "\n",
        "#Saving 100 real images\n",
        "num_samples1 = 99\n",
        "for i in range(num_samples1):\n",
        "  image_real, _ = next(iter(test_loader))  # Get a real image from DataLoader\n",
        "  image_real = image_real.squeeze().detach().numpy()\n",
        "  plt.imsave(os.path.join(real_images_folder, f'real_image_{i}.png'), image_real)\n",
        "\n",
        "# Generate fake images using the generator\n",
        "num_samples2 = 100\n",
        "generator.eval()  # Setting generator to evaluation mode\n",
        "for i in range(num_samples2): #using same num samples as above\n",
        "    noise = create_noise(1, 100)\n",
        "    fake_image = generator(noise).squeeze().detach().numpy()\n",
        "    plt.imsave(os.path.join(fake_images_folder, f'fake_image_{i}.png'), fake_image)\n"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "tbbbmtpkRYR4"
      },
      "outputs": [],
      "source": [
        "fid = fid_score.calculate_fid_given_paths(['/content/fake_images', '/content/real_images'], batch_size=1, device='cpu', dims=64 )\n",
        "\n",
        "print(f\"FID Score: {fid}\")"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "au_MFtAfTCVG"
      },
      "outputs": [],
      "source": [
        "from skimage.metrics import structural_similarity as ssim\n",
        "\n",
        "fake_images_folder = '/content/fake_images'\n",
        "real_images_folder = '/content/real_images'\n",
        "\n",
        "fake_image_files = [os.path.join(fake_images_folder, img) for img in os.listdir(fake_images_folder) if img.endswith('.png')]\n",
        "real_image_files = [os.path.join(real_images_folder, img) for img in os.listdir(real_images_folder) if img.endswith('.png')]\n",
        "\n",
        "\n",
        "# Calculate SSIM scores for all generated and real image pairs\n",
        "ssim_scores = []\n",
        "\n",
        "for fake_image_path, real_image_path in zip(fake_image_files, real_image_files):\n",
        "  #Load images using matplotlib to ensure consistent image reading\n",
        "  fake_image = plt.imread(fake_image_path)\n",
        "  real_image = plt.imread(real_image_path)\n",
        "  score = ssim(fake_image, real_image, multichannel=True)\n",
        "  ssim_scores.append(score)\n",
        "\n",
        "# Print SSIM scores\n",
        "#print(\"SSIM Scores for Generated Images:\")\n",
        "#for i, score in enumerate(ssim_scores, 1):\n",
        "    #print(f\"Generated Image {i}: {score}\")"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "-8flGWY2UEfV"
      },
      "outputs": [],
      "source": [
        "# Calculate SSIM scores for each pair of fake and real images\n",
        "if ssim_scores:  # Check if ssim_scores is not empty\n",
        "    # Calculate average SSIM score\n",
        "    avg_ssim_score = sum(ssim_scores) / len(ssim_scores)\n",
        "    print(\"Average SSIM Score:\", avg_ssim_score)\n",
        "\n",
        "    # Plot all SSIM scores\n",
        "    plt.figure(figsize=(12, 6))\n",
        "    plt.plot(ssim_scores, marker='o')\n",
        "    plt.xlabel('Image Pair')\n",
        "    plt.ylabel('SSIM Score')\n",
        "    plt.title('SSIM Scores for Generated Images')\n",
        "    plt.xticks(rotation=80, ha='right')\n",
        "    plt.grid(True)\n",
        "    plt.show()\n",
        "else:\n",
        "    print(\"No SSIM scores calculated. Ensure there are images in both real_images_folder and fake_images_folder.\")\n"
      ]
    }
  ],
  "metadata": {
    "accelerator": "GPU",
    "colab": {
      "gpuType": "T4",
      "provenance": []
    },
    "kernelspec": {
      "display_name": "Python 3",
      "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.8"
    }
  },
  "nbformat": 4,
  "nbformat_minor": 0
}