Diffusion model - Rice generator.ipynb

{
  "nbformat": 4,
  "nbformat_minor": 0,
  "metadata": {
    "colab": {
      "provenance": [],
      "gpuType": "T4",
      "collapsed_sections": [
        "gUJ9BlYZVtY5",
        "-WkYpjBXV2O4",
        "QRU1oKlUVz1I",
        "6UHTUADig1VG",
        "CLGKffCmg7w1",
        "EaYmAUAEg_0n",
        "h5HOtd9ggxiV"
      ],
      "toc_visible": true
    },
    "kernelspec": {
      "name": "python3",
      "display_name": "Python 3"
    },
    "language_info": {
      "name": "python"
    },
    "accelerator": "GPU"
  },
  "cells": [
    {
      "cell_type": "markdown",
      "source": [
        "Parameters"
      ],
      "metadata": {
        "id": "o5EjgjrUIMq9"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "IMAGE_SHAPE = (16, 16)\n",
        "BATCH_SIZE = 64\n",
        "NO_EPOCHS = 100\n",
        "PRINT_FREQUENCY = 10\n",
        "LR = 0.0003\n",
        "VERBOSE = True\n",
        "LABELS = True"
      ],
      "metadata": {
        "id": "h0Dt61rmXlJL"
      },
      "execution_count": 1,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "# Imports"
      ],
      "metadata": {
        "id": "lZYPD_G_Vp8Z"
      }
    },
    {
      "cell_type": "code",
      "execution_count": 59,
      "metadata": {
        "id": "vaA4flLr9nCq"
      },
      "outputs": [],
      "source": [
        "import torch\n",
        "import torchvision\n",
        "import matplotlib.pyplot as plt\n",
        "import numpy as np\n",
        "import torchvision.transforms as transforms\n",
        "import torch.nn as nn\n",
        "import math\n",
        "import matplotlib.pyplot as plt\n",
        "import torch\n",
        "import urllib\n",
        "import random\n",
        "import PIL\n",
        "import glob\n",
        "from IPython.display import Image"
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "device = 'cuda' if torch.cuda.is_available() else 'cpu'\n",
        "device"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 35
        },
        "id": "aCVJiQACVDgT",
        "outputId": "1c96ff4b-4c22-435a-d59b-1514bd1daa70"
      },
      "execution_count": 19,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "'cuda'"
            ],
            "application/vnd.google.colaboratory.intrinsic+json": {
              "type": "string"
            }
          },
          "metadata": {},
          "execution_count": 19
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "# Models"
      ],
      "metadata": {
        "id": "KM_lwJ3-HQVG"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "## Functions"
      ],
      "metadata": {
        "id": "gUJ9BlYZVtY5"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "class DiffusionModel:\n",
        "    def __init__(self, start_schedule=0.0001, end_schedule=0.02, timesteps = 300):\n",
        "        self.start_schedule = start_schedule\n",
        "        self.end_schedule = end_schedule\n",
        "        self.timesteps = timesteps\n",
        "\n",
        "        self.betas = torch.linspace(start_schedule, end_schedule, timesteps)\n",
        "        self.alphas = 1 - self.betas\n",
        "        self.alphas_cumprod = torch.cumprod(self.alphas, axis=0)\n",
        "\n",
        "    def forward(self, x_0, t, device):\n",
        "        noise = torch.randn_like(x_0)\n",
        "        sqrt_alphas_cumprod_t = self.get_index_from_list(self.alphas_cumprod.sqrt(), t, x_0.shape)\n",
        "        sqrt_one_minus_alphas_cumprod_t = self.get_index_from_list(torch.sqrt(1. - self.alphas_cumprod), t, x_0.shape)\n",
        "\n",
        "        mean = sqrt_alphas_cumprod_t.to(device) * x_0.to(device)\n",
        "        variance = sqrt_one_minus_alphas_cumprod_t.to(device) * noise.to(device)\n",
        "\n",
        "        return mean + variance, noise.to(device)\n",
        "\n",
        "    @torch.no_grad()\n",
        "    def backward(self, x, t, model, **kwargs):\n",
        "        betas_t = self.get_index_from_list(self.betas, t, x.shape)\n",
        "        sqrt_one_minus_alphas_cumprod_t = self.get_index_from_list(torch.sqrt(1. - self.alphas_cumprod), t, x.shape)\n",
        "        sqrt_recip_alphas_t = self.get_index_from_list(torch.sqrt(1.0 / self.alphas), t, x.shape)\n",
        "        mean = sqrt_recip_alphas_t * (x - betas_t * model(x, t, **kwargs) / sqrt_one_minus_alphas_cumprod_t)\n",
        "        posterior_variance_t = betas_t\n",
        "\n",
        "        if t == 0:\n",
        "            return mean\n",
        "        else:\n",
        "            noise = torch.randn_like(x)\n",
        "            variance = torch.sqrt(posterior_variance_t) * noise\n",
        "            return mean + variance\n",
        "\n",
        "    @staticmethod\n",
        "    def get_index_from_list(values, t, x_shape):\n",
        "        batch_size = t.shape[0]\n",
        "        result = values.gather(-1, t.cpu())\n",
        "        return result.reshape(batch_size, *((1,) * (len(x_shape) - 1))).to(t.device)"
      ],
      "metadata": {
        "id": "8JxFRRX0VuB4"
      },
      "execution_count": 58,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "## Unet"
      ],
      "metadata": {
        "id": "-WkYpjBXV2O4"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "class SinusoidalPositionEmbeddings(nn.Module):\n",
        "    def __init__(self, dim):\n",
        "        super().__init__()\n",
        "        self.dim = dim\n",
        "\n",
        "    def forward(self, time):\n",
        "        device = time.device\n",
        "        half_dim = self.dim // 2\n",
        "        embeddings = math.log(10000) / (half_dim - 1)\n",
        "        embeddings = torch.exp(torch.arange(half_dim, device=device) * -embeddings)\n",
        "        embeddings = time[:, None] * embeddings[None, :]\n",
        "        embeddings = torch.cat((embeddings.sin(), embeddings.cos()), dim=-1)\n",
        "        return embeddings"
      ],
      "metadata": {
        "id": "OdNr0tdPXMHl"
      },
      "execution_count": 4,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "class Block(nn.Module):\n",
        "    def __init__(self, channels_in, channels_out, time_embedding_dims, labels, num_filters = 3, downsample=True):\n",
        "        super().__init__()\n",
        "\n",
        "        self.time_embedding_dims = time_embedding_dims\n",
        "        self.time_embedding = SinusoidalPositionEmbeddings(time_embedding_dims)\n",
        "        self.labels = labels\n",
        "        if labels:\n",
        "            self.label_mlp = nn.Linear(1, channels_out)\n",
        "\n",
        "        self.downsample = downsample\n",
        "\n",
        "        if downsample:\n",
        "            self.conv1 = nn.Conv2d(channels_in, channels_out, num_filters, padding=1)\n",
        "            self.final = nn.Conv2d(channels_out, channels_out, 4, 2, 1)\n",
        "        else:\n",
        "            self.conv1 = nn.Conv2d(2 * channels_in, channels_out, num_filters, padding=1)\n",
        "            self.final = nn.ConvTranspose2d(channels_out, channels_out, 4, 2, 1)\n",
        "\n",
        "        self.bnorm1 = nn.BatchNorm2d(channels_out)\n",
        "        self.bnorm2 = nn.BatchNorm2d(channels_out)\n",
        "\n",
        "        self.conv2 = nn.Conv2d(channels_out, channels_out, 3, padding=1)\n",
        "        self.time_mlp = nn.Linear(time_embedding_dims, channels_out)\n",
        "        self.relu = nn.ReLU()\n",
        "\n",
        "    def forward(self, x, t, **kwargs):\n",
        "        o = self.bnorm1(self.relu(self.conv1(x)))\n",
        "        o_time = self.relu(self.time_mlp(self.time_embedding(t)))\n",
        "        o = o + o_time[(..., ) + (None, ) * 2]\n",
        "        if self.labels:\n",
        "            label = kwargs.get('labels')\n",
        "            o_label = self.relu(self.label_mlp(label))\n",
        "            o = o + o_label[(..., ) + (None, ) * 2]\n",
        "\n",
        "        o = self.bnorm2(self.relu(self.conv2(o)))\n",
        "\n",
        "        return self.final(o)"
      ],
      "metadata": {
        "id": "i_KCBZKtXQOF"
      },
      "execution_count": 5,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "class UNet(nn.Module):\n",
        "    def __init__(self, img_channels = 3, time_embedding_dims = 128, labels = False, sequence_channels = (64, 128, 256, 512, 1024)):\n",
        "        super().__init__()\n",
        "        self.time_embedding_dims = time_embedding_dims\n",
        "        sequence_channels_rev = reversed(sequence_channels)\n",
        "\n",
        "        self.downsampling = nn.ModuleList([Block(channels_in, channels_out, time_embedding_dims, labels) for channels_in, channels_out in zip(sequence_channels, sequence_channels[1:])])\n",
        "        self.upsampling = nn.ModuleList([Block(channels_in, channels_out, time_embedding_dims, labels,downsample=False) for channels_in, channels_out in zip(sequence_channels[::-1], sequence_channels[::-1][1:])])\n",
        "        self.conv1 = nn.Conv2d(img_channels, sequence_channels[0], 3, padding=1)\n",
        "        self.conv2 = nn.Conv2d(sequence_channels[0], img_channels, 1)\n",
        "\n",
        "\n",
        "    def forward(self, x, t, **kwargs):\n",
        "        residuals = []\n",
        "        o = self.conv1(x)\n",
        "        for ds in self.downsampling:\n",
        "            o = ds(o, t, **kwargs)\n",
        "            residuals.append(o)\n",
        "        for us, res in zip(self.upsampling, reversed(residuals)):\n",
        "            o = us(torch.cat((o, res), dim=1), t, **kwargs)\n",
        "\n",
        "        return self.conv2(o)"
      ],
      "metadata": {
        "id": "eVz3lJHyXfk8"
      },
      "execution_count": 6,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "## Transforms"
      ],
      "metadata": {
        "id": "QRU1oKlUVz1I"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "transform = transforms.Compose([\n",
        "    transforms.Resize(IMAGE_SHAPE), # Resize the input image\n",
        "    transforms.ToTensor(), # Convert to torch tensor (scales data into [0,1])\n",
        "    transforms.Lambda(lambda t: (t * 2) - 1), # Scale data between [-1, 1]\n",
        "])\n",
        "\n",
        "\n",
        "reverse_transform = transforms.Compose([\n",
        "    transforms.Lambda(lambda t: (t + 1) / 2), # Scale data between [0,1]\n",
        "    transforms.Lambda(lambda t: t.permute(1, 2, 0)), # CHW to HWC\n",
        "    transforms.Lambda(lambda t: t * 255.), # Scale data between [0.,255.]\n",
        "    transforms.Lambda(lambda t: t.cpu().numpy().astype(np.uint8)), # Convert into an uint8 numpy array\n",
        "    transforms.ToPILImage(), # Convert to PIL image\n",
        "])"
      ],
      "metadata": {
        "id": "NuO7pPNTWxDj"
      },
      "execution_count": 7,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "diffusion_model = DiffusionModel()"
      ],
      "metadata": {
        "id": "8ft2cPBeW0YH"
      },
      "execution_count": 8,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "# Load data"
      ],
      "metadata": {
        "id": "VHHzMOC6VlCp"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "class CustomDataset(torch.utils.data.Dataset):\n",
        "    def __init__(self, subset, transform=None, labels=False):\n",
        "        self.subset = subset\n",
        "        self.transform = transform\n",
        "        self.labels = labels\n",
        "\n",
        "    def __getitem__(self, index):\n",
        "        if not self.labels:\n",
        "          x = self.subset[index]\n",
        "          x = x.convert('RGB')\n",
        "          if self.transform:\n",
        "            x = self.transform(x)\n",
        "          return x\n",
        "        else:\n",
        "          x, y = self.subset[index]\n",
        "          x = x.convert('RGB')\n",
        "          if self.transform:\n",
        "            x = self.transform(x)\n",
        "          return x, y\n",
        "\n",
        "    def __len__(self):\n",
        "        return len(self.subset)"
      ],
      "metadata": {
        "id": "h-VCYIEm3i8o"
      },
      "execution_count": 9,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "from google.colab import drive\n",
        "drive.mount('/content/drive')"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "GDTPmV-o86r4",
        "outputId": "6c4b7e97-623b-4016-faf9-3d5e9bf9c350"
      },
      "execution_count": 10,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Mounted at /content/drive\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "# if not extracted\n",
        "# import os\n",
        "# os.chdir('/content/drive/MyDrive/LAMIA_final-project/Rice-dataset')\n",
        "# ! unzip imgs_with_label.zip -d imgs_with_label"
      ],
      "metadata": {
        "id": "m-mR_OlICCc7"
      },
      "execution_count": 11,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "import os\n",
        "from PIL import Image\n",
        "\n",
        "DRIVE_PATH = '/content/drive/MyDrive/LAMIA_final-project/Rice-dataset/imgs_with_label/imgs_with_label'\n",
        "\n",
        "os.chdir(DRIVE_PATH)\n",
        "current_directory = os.getcwd()\n",
        "classes = os.listdir(current_directory)\n",
        "dict_classes = {}\n",
        "for i, clx in enumerate(classes):\n",
        "  dict_classes[clx] = i\n",
        "raw_data = []\n",
        "for cls in classes:\n",
        "  if cls == 'Rice_Citation_Request.txt':\n",
        "    continue\n",
        "  os.chdir(cls)\n",
        "  current_directory = os.getcwd()\n",
        "  imgs = os.listdir(current_directory)\n",
        "  print(len(imgs))\n",
        "  for item in imgs:\n",
        "    raw_data.append((Image.open(item), dict_classes[cls]))\n",
        "  os.chdir('../')\n",
        "os.chdir('/content')"
      ],
      "metadata": {
        "id": "LWLrUNxwQcbd",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "3b07af4f-0f25-45fe-c641-d127abf33d8d"
      },
      "execution_count": 11,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "1000\n",
            "1000\n",
            "1000\n",
            "1000\n",
            "1000\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "random.shuffle(raw_data)"
      ],
      "metadata": {
        "id": "Dk3Os3thJzNn"
      },
      "execution_count": 12,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "raw_data[:5]"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "9LQfDQEJFgUy",
        "outputId": "56b3cd19-ec1e-4b1d-d6f0-c019968f3cf2"
      },
      "execution_count": 13,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "[(<PIL.JpegImagePlugin.JpegImageFile image mode=RGB size=250x250>, 0),\n",
              " (<PIL.JpegImagePlugin.JpegImageFile image mode=RGB size=250x250>, 3),\n",
              " (<PIL.JpegImagePlugin.JpegImageFile image mode=RGB size=250x250>, 0),\n",
              " (<PIL.JpegImagePlugin.JpegImageFile image mode=RGB size=250x250>, 2),\n",
              " (<PIL.JpegImagePlugin.JpegImageFile image mode=RGB size=250x250>, 3)]"
            ]
          },
          "metadata": {},
          "execution_count": 13
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "SPLIT_TRAIN_TEST = 1000\n",
        "train_data = raw_data[:SPLIT_TRAIN_TEST]\n",
        "test_data = raw_data[SPLIT_TRAIN_TEST:]\n",
        "\n",
        "train_dataset = CustomDataset(train_data, transform=transform, labels=LABELS)\n",
        "train_loader = torch.utils.data.DataLoader(train_dataset, batch_size=BATCH_SIZE, shuffle=True, num_workers=2, drop_last=True)\n",
        "\n",
        "test_dataset = CustomDataset(train_data, transform=transform, labels=LABELS)\n",
        "test_loader = torch.utils.data.DataLoader(train_dataset, batch_size=BATCH_SIZE, shuffle=True, num_workers=2, drop_last=True)"
      ],
      "metadata": {
        "id": "jiJ7H8b0ZiUI"
      },
      "execution_count": 14,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "import torchvision.transforms as T\n",
        "from PIL import Image\n",
        "trans = T.ToPILImage()\n",
        "img = trans(train_dataset.__getitem__(3)[0])\n",
        "img"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 34
        },
        "id": "FDB0FQvUdBUS",
        "outputId": "f22640dd-c111-4aa4-837c-f64a08041ad1"
      },
      "execution_count": 15,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "<PIL.Image.Image image mode=RGB size=16x16>"
            ],
            "image/png": "iVBORw0KGgoAAAANSUhEUgAAABAAAAAQCAIAAACQkWg2AAABEklEQVR4nGNkZGRkIAUwsbCwMDExkaCBgYGBiYmJeD1QdcTrQSjC1CAlJZOTU+Lg4IZdAzJgYWEJCYni4ZORkdPLzMxHdgXLv3//0MxmY2MrKWl89Ox9SVnMtSsXdu1YguwEpn8wABHi4+ObO3fljz/sDg5OTAwM+/btuXHjGrKDmRgYGCAa/vz5w8PDt3Pn8cdPP+ro6DAxsSxYMEtJSeTFi2fIGhiRI27i5NnvPzJKSUkxMDB0dDTJSPAcOrSPgeEfxFdYQsnOzomJgenapUve7rZsTF8OHdoDUY0MUGyQkZFzc/N59ODesROHvn37hhZuWDRgAojT4UFCWAPc4D9//qD7ASuAmM2A1dN4nITMBgCfJFw/gc1U3gAAAABJRU5ErkJggg==\n"
          },
          "metadata": {},
          "execution_count": 15
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "# Train model"
      ],
      "metadata": {
        "id": "LovFoTHCV8PI"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "from PIL import ImageFile\n",
        "ImageFile.LOAD_TRUNCATED_IMAGES = True"
      ],
      "metadata": {
        "id": "5xKPDV2FVs2E"
      },
      "execution_count": 16,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "unet = UNet(labels=LABELS)\n",
        "unet.to(device)\n",
        "optimizer = torch.optim.Adam(unet.parameters(), lr=LR)"
      ],
      "metadata": {
        "id": "RRxgPQ7hIH4O"
      },
      "execution_count": 21,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "epoch_loss = []\n",
        "epoch_loss_val = []\n",
        "to_gif = []\n",
        "for epoch in range(NO_EPOCHS):\n",
        "    mean_epoch_loss = []\n",
        "    mean_epoch_loss_val = []\n",
        "    for batch, label in train_loader:\n",
        "        label = torch.Tensor(label)\n",
        "        t = torch.randint(0, diffusion_model.timesteps, (BATCH_SIZE,)).long().to(device)\n",
        "        batch = batch.to(device)\n",
        "        batch_noisy, noise = diffusion_model.forward(batch, t, device)\n",
        "        predicted_noise = unet(batch_noisy, t, labels = label.reshape(-1,1).float().to(device))\n",
        "\n",
        "        optimizer.zero_grad()\n",
        "        loss = torch.nn.functional.mse_loss(noise, predicted_noise)\n",
        "        mean_epoch_loss.append(loss.item())\n",
        "        loss.backward()\n",
        "        optimizer.step()\n",
        "\n",
        "    for batch, label in test_loader:\n",
        "        t = torch.randint(0, diffusion_model.timesteps, (BATCH_SIZE,)).long().to(device)\n",
        "        batch = batch.to(device)\n",
        "\n",
        "        batch_noisy, noise = diffusion_model.forward(batch, t, device)\n",
        "        predicted_noise = unet(batch_noisy, t, labels = label.reshape(-1,1).float().to(device))\n",
        "\n",
        "        loss = torch.nn.functional.mse_loss(noise, predicted_noise)\n",
        "        mean_epoch_loss_val.append(loss.item())\n",
        "\n",
        "    img = torch.randn((1, 3) + IMAGE_SHAPE).to(device)\n",
        "    for i in reversed(range(diffusion_model.timesteps)):\n",
        "        t = torch.full((1,), i, dtype=torch.long, device=device)\n",
        "        labels = torch.tensor([0]*1).resize(1, 1).float().to(device)\n",
        "        img = diffusion_model.backward(x=img, t=t, model=unet.eval().to(device), labels=labels)\n",
        "    to_gif.append(img.squeeze())\n",
        "\n",
        "    epoch_loss.append(np.mean(mean_epoch_loss))\n",
        "    epoch_loss_val.append(np.mean(mean_epoch_loss_val))\n",
        "\n",
        "    if epoch % PRINT_FREQUENCY == 0:\n",
        "        print('---')\n",
        "        print(f\"Epoch: {epoch} | Train Loss {np.mean(mean_epoch_loss)} | Val Loss {np.mean(mean_epoch_loss_val)}\")\n",
        "        torch.save(unet.state_dict(), f\"epoch: {epoch}\")"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "JPaV1Tr0Xona",
        "outputId": "c3a7f6a9-09d5-4219-ed25-f4bde014c96a"
      },
      "execution_count": 22,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "---\n",
            "Epoch: 0 | Train Loss 0.8606915791829427 | Val Loss 0.6781526843706767\n",
            "---\n",
            "Epoch: 10 | Train Loss 0.157571479678154 | Val Loss 0.1472970277070999\n",
            "---\n",
            "Epoch: 20 | Train Loss 0.09127146750688553 | Val Loss 0.09314400454362233\n",
            "---\n",
            "Epoch: 30 | Train Loss 0.07200307125846545 | Val Loss 0.061171760658423106\n",
            "---\n",
            "Epoch: 40 | Train Loss 0.05668814107775688 | Val Loss 0.05791905398170153\n",
            "---\n",
            "Epoch: 50 | Train Loss 0.0472418246169885 | Val Loss 0.04888762459158898\n",
            "---\n",
            "Epoch: 60 | Train Loss 0.044136946896711986 | Val Loss 0.044768662005662915\n",
            "---\n",
            "Epoch: 70 | Train Loss 0.040739249686400095 | Val Loss 0.041110216577847795\n",
            "---\n",
            "Epoch: 80 | Train Loss 0.044535591701666516 | Val Loss 0.03797693674763044\n",
            "---\n",
            "Epoch: 90 | Train Loss 0.0353089340031147 | Val Loss 0.032133104155460994\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "# Plots"
      ],
      "metadata": {
        "id": "6UHTUADig1VG"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "## Generating images"
      ],
      "metadata": {
        "id": "CLGKffCmg7w1"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "# Define the number of rows and columns in the grid\n",
        "num_rows = len(classes)\n",
        "num_cols = 5\n",
        "\n",
        "# Create a new figure for the grid\n",
        "fig, axes = plt.subplots(num_rows, num_cols, figsize=(15, 15))\n",
        "\n",
        "# Iterate through each class\n",
        "for cc, class_name in enumerate(classes):\n",
        "    # Iterate through 5 examples for each class\n",
        "    for example_index in range(5):\n",
        "        img = torch.randn((1, 3) + IMAGE_SHAPE).to(device)\n",
        "        for i in reversed(range(diffusion_model.timesteps)):\n",
        "            t = torch.full((1,), i, dtype=torch.long, device=device)\n",
        "            labels = torch.tensor([0]*1).resize(1, 1).float().to(device)\n",
        "            img = diffusion_model.backward(x=img, t=t, model=unet.eval().to(device), labels=labels)\n",
        "\n",
        "        # Display the image in the corresponding subplot\n",
        "        ax = axes[cc, example_index]\n",
        "        ax.imshow(reverse_transform(img.squeeze()))\n",
        "        ax.set_title(class_name)\n",
        "        ax.axis('off')\n",
        "\n",
        "# Show the grid of images\n",
        "plt.tight_layout()\n",
        "plt.show()\n"
      ],
      "metadata": {
        "id": "4QZRDVSJDmS9",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 1000
        },
        "outputId": "b747cd75-bdf7-4750-a39f-8b63a8fad5da"
      },
      "execution_count": 56,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stderr",
          "text": [
            "/usr/local/lib/python3.10/dist-packages/torch/_tensor.py:836: UserWarning: non-inplace resize is deprecated\n",
            "  warnings.warn(\"non-inplace resize is deprecated\")\n"
          ]
        },
        {
          "output_type": "display_data",
          "data": {
            "text/plain": [
              "<Figure size 1500x1500 with 25 Axes>"
            ],
            "image/png": "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\n"
          },
          "metadata": {}
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "## Losses"
      ],
      "metadata": {
        "id": "EaYmAUAEg_0n"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "plt.plot(epoch_loss, label='Train Loss')\n",
        "plt.plot(epoch_loss_val, label='Validation Loss')\n",
        "\n",
        "plt.xlabel('Epochs')\n",
        "plt.ylabel('Loss')\n",
        "\n",
        "plt.legend()\n",
        "\n",
        "plt.show()"
      ],
      "metadata": {
        "id": "DaJeY4AdMKOf",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 449
        },
        "outputId": "43de38e4-c5a5-46a5-d90d-275d0b4ad40d"
      },
      "execution_count": 74,
      "outputs": [
        {
          "output_type": "display_data",
          "data": {
            "text/plain": [
              "<Figure size 640x480 with 1 Axes>"
            ],
            "image/png": "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\n"
          },
          "metadata": {}
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "## Turn images into GIF"
      ],
      "metadata": {
        "id": "h5HOtd9ggxiV"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "to_gif_pil = [reverse_transform(x) for x in to_gif]"
      ],
      "metadata": {
        "id": "MA-gHkbLaKk7"
      },
      "execution_count": 62,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "SAVE_PATH = '/content/drive/MyDrive/LAMIA_final-project/Rice-dataset/GIF/'\n",
        "for i, img in enumerate(to_gif_pil):\n",
        "  img = img.resize((512, 512))\n",
        "  img.save(f'{SAVE_PATH}epoch-{i}.jpg')"
      ],
      "metadata": {
        "id": "JKgNc1LgajZq"
      },
      "execution_count": 63,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "def make_gif(frame_folder):\n",
        "    frames = [Image.open(image) for image in glob.glob(f\"{frame_folder}*.jpg\")]\n",
        "    frame_one = frames[0]\n",
        "    frame_one.save(f'{SAVE_PATH}rice-stable-diffusion.gif', format=\"GIF\", append_images=frames,\n",
        "               save_all=True, duration=500, loop=0)"
      ],
      "metadata": {
        "id": "xNclj9aZc0Uc"
      },
      "execution_count": 64,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "from PIL import Image\n",
        "make_gif(SAVE_PATH)"
      ],
      "metadata": {
        "id": "hy9qR-zqdK7d"
      },
      "execution_count": 67,
      "outputs": []
    }
  ]
}