{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<img src=\"pic.png\" width=\"1000px\">"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 57,
   "metadata": {},
   "outputs": [],
   "source": [
    "import torch\n",
    "from torchvision import datasets, transforms\n",
    "from torch.utils.data import DataLoader\n",
    "import matplotlib.pyplot as plt\n",
    "import torchvision.transforms as transforms\n",
    "from sklearn.decomposition import PCA\n",
    "import torch.nn as nn\n",
    "from einops import rearrange\n",
    "from torchsummary import summary\n",
    "import torch.optim as optim\n",
    "import math\n",
    "from tqdm import tqdm\n",
    "import cv2\n",
    "import numpy as np\n",
    "from torch import Tensor\n",
    "\n",
    "\n",
    "\n",
    "import lightning as L"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 58,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "cpu\n"
     ]
    }
   ],
   "source": [
    "device = torch.device(\"cuda\" if torch.cuda.is_available() else \"cpu\")\n",
    "print(device)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Set global seed to compare same initialized weights\n",
    "torch.manual_seed(0)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 59,
   "metadata": {},
   "outputs": [],
   "source": [
    "class VQ_VAE(L.LightningModule):\n",
    "    def __init__(self, input_dim, codebook_size, encoding_dim, hidden_dim, beta):\n",
    "        super().__init__()\n",
    "\n",
    "        assert len(input_dim) == 3, \"Input dimension must be 3D\"\n",
    "        assert len(encoding_dim) == 3, \"Encoding dimension must be 3D\"\n",
    "\n",
    "        # Set the dimensions\n",
    "        self.input_dim = input_dim\n",
    "        self.codebook_size = codebook_size\n",
    "        self.encoding_dim = encoding_dim\n",
    "        self.hidden_dim = hidden_dim\n",
    "        self.beta = beta\n",
    "\n",
    "        # Unwrap input dimension, extract the number of channels, height and width\n",
    "        self._input_c = input_dim[0]\n",
    "        self._input_h = input_dim[1]\n",
    "        self._input_w = input_dim[2]\n",
    "        self._input_dim_flat = self._input_c * self._input_h * self._input_w\n",
    "\n",
    "        # Unwrap encoding dimension\n",
    "        self._embedding_dim = encoding_dim[0]\n",
    "        self._encoding_h = encoding_dim[1]\n",
    "        self._encoding_w = encoding_dim[2]\n",
    "\n",
    "        # Calculate flat encoding dimension\n",
    "        self._encoding_dim_flat = self._embedding_dim * self._encoding_h * self._encoding_w\n",
    "    \n",
    "\n",
    "        # Setup encoder layers\n",
    "        self.enc_fc1 = nn.Linear(self._input_dim_flat, self.hidden_dim)\n",
    "        self.enc_fc2 = nn.Linear(self.hidden_dim, self._encoding_dim_flat)\n",
    "        self.relu = nn.ReLU()\n",
    "\n",
    "        # Setup decoder layers\n",
    "        self.dec_fc1 = nn.Linear(self._encoding_dim_flat, self.hidden_dim)\n",
    "        self.dec_fc2 = nn.Linear(self.hidden_dim, self._input_dim_flat)\n",
    "        self.sigmoid = nn.Sigmoid()\n",
    "\n",
    "        # Setup codebook embeddings\n",
    "        self.codebook = nn.Embedding(self.codebook_size, self._embedding_dim)\n",
    "        assert self.codebook.weight.requires_grad == True, \"Codebook should be learnable\"\n",
    "        # TODO: Initialize codebook uniformly, like in the paper\n",
    "        nn.init.uniform_(self.codebook.weight, -1/self.codebook_size, 1/self.codebook_size)\n",
    "\n",
    "        # For now we initialize randomly the codebook vectors. We act like stupid, then if it works, we use uniform like in other implementations.\n",
    " \n",
    "    def encode(self, x):\n",
    "        \"\"\"\n",
    "        x: Input image of shape (b, c, h, w)\n",
    "        Output: z - encoded image of shape (b, h, w, c)\n",
    "        \"\"\"\n",
    "        assert x.shape[1:] == (self._input_c, self._input_h, self._input_w)\n",
    "\n",
    "        # Run the layers\n",
    "        x = rearrange(x, 'b c h w -> b (c h w)') # Flatten the input\n",
    "        x = self.relu(self.enc_fc1(x))\n",
    "        x = self.relu(self.enc_fc2(x))\n",
    "\n",
    "        # Unflatten, last dimension is embedding dim\n",
    "        x = rearrange(x, 'b (c h w) -> b h w c', c=self._embedding_dim, h=self._encoding_h, w=self._encoding_w)\n",
    "\n",
    "        return x\n",
    "    \n",
    "    def decode(self, z_q):\n",
    "        \"\"\"        \n",
    "        Input: z_q: Quantized encodings of shape (b h w c)\n",
    "\n",
    "        Returns the reconstructed image x_hat of shape (b c h w)\n",
    "        \"\"\"\n",
    "        # Rearrange so we work on the values, also flatten because of fully-connected layers\n",
    "        z_q = rearrange(z_q, 'b h w c -> b (c h w)')\n",
    "\n",
    "        # Run the layers\n",
    "        x = self.relu(self.dec_fc1(z_q))\n",
    "        x = self.relu(self.dec_fc2(x))\n",
    "        x_hat = self.sigmoid(x)\n",
    "\n",
    "        # Rearrange back to image shape\n",
    "        x_hat = rearrange(x_hat, 'b (c h w) -> b c h w', c=self._input_c, h=self._input_h, w=self._input_w)\n",
    "\n",
    "        return x_hat\n",
    "    \n",
    "    def quantize(self, z):\n",
    "        \"\"\"\n",
    "        z_e: (batch_size, encoding_height, encoding_width, embedding_dim)\n",
    "\n",
    "        Get closest (euclidean distance) codebook vector z_q given z.\n",
    "\n",
    "        Returns quantized encodings z_q of shape (b h w c)\n",
    "        \"\"\"\n",
    "        assert z.shape[1:] == (self._encoding_h, self._encoding_w, self._embedding_dim)\n",
    "\n",
    "        flat_input = rearrange(z, 'b h w c -> (b h w) c')\n",
    "\n",
    "        # TODO: Replace this by my own distances calculation\n",
    "        # Equation: ||z - e||^2 = ||z||^2 + ||e||^2 - 2 * <z,e>\n",
    "        distances = (torch.sum(flat_input**2, dim=1, keepdim=True)\n",
    "            + torch.sum(self.codebook.weight**2, dim=1)\n",
    "            - 2 * torch.matmul(flat_input, self.codebook.weight.t()))\n",
    "\n",
    "        #distances = self.calculate_distances(z)\n",
    "\n",
    "        # Distances is shape (batch, height, width, embed_dim)\n",
    "        # Get the index of the closest codebook vector\n",
    "        min_indices = torch.argmin(distances, dim=1)\n",
    "\n",
    "        # We now have matrix of one-hot vectors, with \"1\" at the index of the closest codebook vector, given by \"min_indices\"\n",
    "        one_hot = nn.functional.one_hot(min_indices, num_classes=self.codebook_size)\n",
    "\n",
    "        # Now to get the value of the closest codebook vector, we multiply the one-hot matrix with the codebook matrix\n",
    "        z_q = torch.matmul(one_hot.float(), self.codebook.weight)\n",
    "\n",
    "        # Reshape back\n",
    "        z_q = rearrange(z_q, '(b h w) c -> b h w c', b=z.shape[0], h=self._encoding_h, w=self._encoding_w)\n",
    "\n",
    "        return z_q\n",
    "\n",
    "    def forward(self, x):\n",
    "        assert x.shape[1:] == (self._input_c, self._input_h, self._input_w)\n",
    "\n",
    "        # Encode\n",
    "        z = self.encode(x)\n",
    "\n",
    "        # Quantize the latent vector\n",
    "        z_q = self.quantize(z)\n",
    "\n",
    "        # Add streight through estimator\n",
    "        z_q = z + (z_q - z).detach()\n",
    "        \n",
    "        # Decode\n",
    "        x_reconstructed = self.decode(z_q)\n",
    "\n",
    "        # The output image should have the same shape as the input image\n",
    "        assert x_reconstructed.shape == x.shape\n",
    "\n",
    "        # Return x hat (and also some other stuff for loss calculation and debugging)\n",
    "        return x_reconstructed, z, z_q\n",
    "\n",
    "    def training_step(self, batch, batch_idx):\n",
    "        images, _ = batch\n",
    "    \n",
    "        # Forward pass\n",
    "        x_hat, z_e, z_q = self(images)\n",
    "\n",
    "        # Calculate loss\n",
    "        # Reconstruction loss\n",
    "        recon_loss = nn.BCELoss(reduction='sum')(x_hat, images)\n",
    "        # recon_loss = nn.functional.mse_loss(x_hat, images)\n",
    "\n",
    "        # Quantization loss\n",
    "        quant_loss = nn.functional.mse_loss(z_e.detach(), z_q) # TODO: This loss is increasing\n",
    "        # quant_loss = torch.mean(torch.norm((emb - z_e.detach())**2, 2, 1))\n",
    "\n",
    "        # Commitment loss\n",
    "        commit_loss = nn.functional.mse_loss(z_q.detach(), z_e)\n",
    "\n",
    "        # Total loss\n",
    "        loss = recon_loss + quant_loss + self.beta * commit_loss\n",
    "\n",
    "        values = {\"loss\": loss, \"recon_loss\": recon_loss, \"quant_loss\": quant_loss, \"commit_loss\": commit_loss}\n",
    "        self.log_dict(values)\n",
    "\n",
    "        return loss\n",
    "    \n",
    "    def configure_optimizers(self):\n",
    "        lr = 1e-3\n",
    "        optimizer = optim.Adam(self.parameters(), lr=lr)\n",
    "        return optimizer\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 60,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Model\n",
    "input_dim = (3, 32, 32)\n",
    "codebook_size = 512\n",
    "\n",
    "embedding_dim = 64 # Dimension of each codebook vector\n",
    "encoding_dim = (embedding_dim, 8, 8)\n",
    "\n",
    "hidden_dim = 1024\n",
    "\n",
    "beta = 0.25"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 61,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "----------------------------------------------------------------\n",
      "        Layer (type)               Output Shape         Param #\n",
      "================================================================\n",
      "            Linear-1                 [-1, 1024]       3,146,752\n",
      "              ReLU-2                 [-1, 1024]               0\n",
      "            Linear-3                 [-1, 4096]       4,198,400\n",
      "              ReLU-4                 [-1, 4096]               0\n",
      "            Linear-5                 [-1, 1024]       4,195,328\n",
      "              ReLU-6                 [-1, 1024]               0\n",
      "            Linear-7                 [-1, 3072]       3,148,800\n",
      "              ReLU-8                 [-1, 3072]               0\n",
      "           Sigmoid-9                 [-1, 3072]               0\n",
      "================================================================\n",
      "Total params: 14,689,280\n",
      "Trainable params: 14,689,280\n",
      "Non-trainable params: 0\n",
      "----------------------------------------------------------------\n",
      "Input size (MB): 0.01\n",
      "Forward/backward pass size (MB): 0.16\n",
      "Params size (MB): 56.04\n",
      "Estimated Total Size (MB): 56.21\n",
      "----------------------------------------------------------------\n"
     ]
    }
   ],
   "source": [
    "model = VQ_VAE(input_dim, codebook_size, encoding_dim, hidden_dim, beta)\n",
    "model.to(device)\n",
    "summary(model, (3, 32, 32))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Quantization of z_e\n",
    "\n",
    "To quantisize the z_e we run `torch.norm()` which calculate length of vector.\n",
    "\n",
    "For instance if `a = torch.tensor([1, 1])` then the length of vector is `sqrt(1^2 + 1^2) = sqrt(2) = 1.4142`\n",
    "\n",
    "So we do: `torch.norm(z_e - codebook)` which means we measure distance between two vectors.\n",
    "\n",
    "Then we apply `argmin`: `torch.argmin(torch.norm(z_e - codebook))` to get the index of the closest vector in the codebook.\n",
    "\n",
    "Finally we get the quantized vector: `codebook[torch.argmin(torch.norm(z_e - codebook))]`"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Define dataset and dataloader"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 62,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Files already downloaded and verified\n",
      "Files already downloaded and verified\n"
     ]
    }
   ],
   "source": [
    "# Transformations\n",
    "# Note: normalizing the images to have values in the range [0, 1] is important for the calculation of BCE loss\n",
    "transform = transforms.Compose([\n",
    "    transforms.ToTensor(),\n",
    "    lambda x: (x - x.min()) / (x.max() - x.min()) # Normalize to [0, 1]\n",
    "])\n",
    "\n",
    "# Load dataset\n",
    "# CIFAR-10\n",
    "train_dataset = datasets.CIFAR10(root=\"./data\", train=True, download=True, transform=transform)\n",
    "test_dataset = datasets.CIFAR10(root=\"./data\", train=False, download=True, transform=transform)\n",
    "\n",
    "# Data loaders\n",
    "test_loader_batch = 32\n",
    "train_loader = DataLoader(train_dataset, shuffle=True)\n",
    "test_loader = DataLoader(test_dataset, batch_size=test_loader_batch, shuffle=False)\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Train"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 63,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "GPU available: True (mps), used: True\n",
      "TPU available: False, using: 0 TPU cores\n",
      "HPU available: False, using: 0 HPUs\n",
      "\n",
      "  | Name     | Type      | Params | Mode \n",
      "-----------------------------------------------\n",
      "0 | enc_fc1  | Linear    | 3.1 M  | train\n",
      "1 | enc_fc2  | Linear    | 4.2 M  | train\n",
      "2 | relu     | ReLU      | 0      | train\n",
      "3 | dec_fc1  | Linear    | 4.2 M  | train\n",
      "4 | dec_fc2  | Linear    | 3.1 M  | train\n",
      "5 | sigmoid  | Sigmoid   | 0      | train\n",
      "6 | codebook | Embedding | 32.8 K | train\n",
      "-----------------------------------------------\n",
      "14.7 M    Trainable params\n",
      "0         Non-trainable params\n",
      "14.7 M    Total params\n",
      "58.888    Total estimated model params size (MB)\n",
      "7         Modules in train mode\n",
      "0         Modules in eval mode\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Epoch 4: 100%|██████████| 256/256 [00:08<00:00, 28.57it/s, v_num=22]"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "`Trainer.fit` stopped: `max_epochs=5` reached.\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Epoch 4: 100%|██████████| 256/256 [00:09<00:00, 27.86it/s, v_num=22]\n"
     ]
    }
   ],
   "source": [
    "trainer = L.Trainer(limit_train_batches=256, max_epochs=5)\n",
    "trainer.fit(model=model, train_dataloaders=train_loader)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 64,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "torch.Size([32, 3, 32, 32])\n",
      "torch.Size([8, 3, 32, 32])\n"
     ]
    },
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 2000x500 with 16 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "# Plot 8 images (original image) and to their right plot the reconstructed image\n",
    "model.eval()\n",
    "with torch.no_grad():\n",
    "    images, labels = next(iter(test_loader))\n",
    "    assert len(images) >= 8, \"Test loader must have at least 8 images, got only {}\".format(len(images))\n",
    "    print(images.shape)\n",
    "    images = images[:8].to(device)\n",
    "\n",
    "    outputs, _, _ = model(images)\n",
    "\n",
    "    images = images.cpu()\n",
    "    outputs = outputs.cpu()\n",
    "\n",
    "    print(outputs.shape)\n",
    "\n",
    "    fig, axes = plt.subplots(2, 8, figsize=(20, 5))\n",
    "    for i in range(8):\n",
    "        # Change the order of the channels to (h, w, c) for matplotlib\n",
    "        axes[0, i].imshow(images[i].permute(1, 2, 0))\n",
    "        axes[0, i].axis('off')\n",
    "        # Add title for the image\n",
    "        axes[0, i].set_title(f\"{train_dataset.classes[labels[i]]}\")\n",
    "        axes[1, i].imshow(outputs[i].permute(1, 2, 0))\n",
    "        axes[1, i].axis('off')\n",
    "\n",
    "    plt.show()"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "base",
   "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.12.2"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}